Michael Thomas Flanagan's Java Scientific LibraryRegression Class:     Linear and Non-linear Regression

Last update: 13 August 2016                                                                                                                             PERMISSION TO USE
Home Page of Michael Thomas Flanagan's Java Scientific Library.

This class contains the methods for performing the following regressions:
 Fitting to a constant; yi = a0; Linear regression with intercept; yi = a0 + a1.x0,i + a2.x1,i + . . . ; General linear regression; yi = a0.f1(x0, x1 . .) + a1.f2(x0, x1 . .) + . . . ; Polynomial fitting; yi = a0 + a1.xi + a2.xi2 + a3.xi3. . .;                            yi = a0 + a1.xian+1 + a2.xian+2 + . . . + an.xia2n+1 [non-linear] Non linear regression; Nelder and Mead Simplex. [Unconstrained and constrained] y = f1(a0,a1,a2..., x0,x1,x2...) y0 = f1(a0,a1,a2..., x0,x1,x2...) y1 = f2(a0,a1,a2..., x0,x1,x2...) . . . yn = fn(a0,a1,a2..., x0,x1,x2...) Fitting data to exponentials Fitting to a single exponential, yi = a.exp(b.xi) Fitting to a multiple exponentials Fitting to yi = a.(1 - exp(b.xi)) See also Fitting to an Exponential Distribution Fitting data to a Rectangular Hyperbola Fitting data to a Sigmoidal Function Sigmoid threshold function: y = Ao/(1 + e-α(x-θ)) Hill/Sips Sigmoid: y = xnAo/(θn + xn) Four parameter logistic (EC50 dose response curve):y = top + (bottom - top)/(1 + (x/EC50)Hill Slope) Five parameter logistic:y = top + (bottom - top)/(1 + (x/C50)Hill Slope)asymm Fitting data to a Scaled Heaviside Step Function Fitting data to a Gaussian Distribution [Normal Distribution]; See also ProbabilityPlot Fitting data to a Log-normal Distribution Two Parameter Statistic ; Three Parameter Statistic ; Fitting data to a Logistic Distribution [sech squared Distribution]; See also ProbabilityPlot Fitting data to a Lorentzian Distribution [Cauchy Distribution]; See also ProbabilityPlot Fitting data to a Poisson Distribution; Fitting data to a Beta Distribution Beta Distribution on the interval [0,1]; Beta Distribution on the interval [min, max]; Fitting data to a Gamma Distribution Three Parameter Gamma Distribution; Standard Gamma Distribution; Fitting data to an Erlang Distribution Fitting data to a Type 1 Extreme Value Distribution: Minimum order statistic General Gumbel Distribution One Parameter Gumbel Distribution Standard Gumbel Distribution See also ProbabilityPlot Maximum order statistic General Gumbel Distribution One Parameter Gumbel Distribution Standard Gumbel Distribution See also ProbabilityPlot Fitting data to a Type 2 Extreme Value Distribution: General Fréchet Distribution Two Parameter Fréchet Distribution Standard Fréchet Distribution See also ProbabilityPlot Fitting data to a Type 3 Extreme Value Distribution: Weibull Distribution General Weibull Distribution Two Parameter Weibull Distribution Standard Weibull Distribution See also ProbabilityPlot Exponential Distribution General Exponential Distribution One Parameter Exponential Distribution Standard Exponential Distribution See also ProbabilityPlot Rayleigh Distribution See also ProbabilityPlot Fitting data to a Pareto Distribution Shifted Pareto Distribution Two Parameter Pareto Distribution One Parameter Pareto Distribution See also ProbabilityPlot Fitting data to a F-Distribution See ProbabilityPlot Check best fit model: Extra sum of squares analysis Check normality of the data: See separate class Normality Check normality of the residuals Durbin-Watson d Statistic Fitting Immunoassay data to model assay equations See separate subclass ImmunoAssay Fitting Impedance and Electrochemical Impedance Spectradata to a circuit model See separate subclass ImpedSpecRegression Smoothing 1D data, i.e. a curve See a separate class CurveSmooth Smoothing 2D data, i.e. a surface See a separate class SurfaceSmooth Smoothing 3D data See a separate class ThreeDimensionalSmooth
The regressions may be performed on sets of x - y data or on a single set of data which is first binned into an histogram.

Weighted regression using both dependent and independent variable errors
The above listed regressions may all be performed as unweighted regressions or as classically weighted regressions, i.e. regressions in which the weighting factors are equated to the measurement errors in the dependent variable (y) and the dependent variables (x) are assumed to be error free. The following regressions may also be performed as weighted regressions in which the weighting factors are derived from the measurement errors in both the dependent and independent variables:
Coding a user supplied function
The sum of squares function required by the non-linear regression procedure is supplied via one of the following interfaces:
• RegressionFunction, typically used for functions with a one-dimensional y array and either no weighting or weighting derived only from the measurement errors in the dependent (y) variable
• RegressionFunction2 typically used for functions with a two-dimensional y array and either no weighting or weighting derived only from the measurement errors in the dependent (y) variable
• RegressionFunction3 typically used for functions with weighting derived from the measurement errors in both the dependent (y) variable and the independent (x) variables, irrespective of the dimensionality of the dependent (y) array.
Covariance matrix options
The covariance matrix used in the statistical analysis of the best estimates may, in the case of non-linear regression, be calculated either numerically or analytically. If the latter option is chosen the first and second derivatives of the fitted function for pairs of parameters are supplied via an interface, RegressionDerivativeFunction or RegressionDerivativeFunction2 (more than one dependent variable).

Deprecated and renamed methods
Method names are occasionly changed to maintain naming consistency and some methods are occasionally deprecated. The older named methods are always retained in the flanagan.jar file but may not be listed on this page.

Warning before attempting a non-linear regression: Click here.

Fitting to statistical distributions and unbinned data: the ProbabilityPlot class may be as or more useful in fitting data to statistical distributions if the data is unbinned.

Outlier removal methods may be found in the Outliers Class.

 import statement/s: For all regressions      import flanagan.analysis.Regression; In addition for relevant non-linear regressions      import flanagan.analysis.RegressionFunction;      import flanagan.analysis.RegressionFunction2;      import flanagan.analysis.RegressionFunction3;
Related classes

### SUMMARY OF CONSTRUCTORS AND METHODS

 Constructors public Regression(double[ ][ ] xdata, double[ ] ydata, double[ ] yErrors) public Regression(double[ ][ ] xdata, double[ ] ydata, double[ ][] xerrors, double[ ] yerrors) public Regression(double[ ][ ] xdata, double[ ][] ydata, double[ ][ ] yerrors) public Regression(double[ ][ ] xdata, double[ ][] ydata, double[ ][ ] xerrors, double[ ][ ] yerrors) public Regression(double[ ] xdata, double[ ] ydata, double[ ] yErrors) public Regression(double[ ] xdata, double[ ] ydata, double[ ] xerrors, double[ ] yerrors) public Regression(double[ ] xdata, double[ ][] ydata, double[ ][ ] yerrors) public Regression(double[ ] xdata, double[ ][] ydata, double[ ] xerrors, double[ ][ ] yerrors) public Regression(double[ ][ ] xdata, double[ ] ydata) public Regression(double[ ][ ] xdata, double[ ][] ydata) public Regression(double[ ] xdata, double[ ] ydata) public Regression(double[ ] xdata, double[ ][] ydata) public Regression(double[ ] xdata, double binWidth, double binZero) public Regression(double[ ] xdata, double binWidth) LinearRegression Fitting to a constantyi = a0 public void constant() public void constantPlot() public void constantPlot(String xLegend, String yLegend) Linear with interceptyi = a0+a1.x0,i+a2.x1,i+... public void linear() public void linear(double fixedIntercept) public void linearPlot() public void linearPlot(double fixedIntercept) public void linearPlot(String xLegend, String yLegend) public void linearPlot(double fixedIntercept, String xLegend, String yLegend) General linearyi = a0.f1(x0,x1..)+a1.f2(x0,x1+...) public void linearGeneral() public void linearGeneralPlot() public void linearGeneralPlot(String xLegend, String yLegend) Polynomialyi = a0+a1.x+a2.x2+a3x3 ... public void polynomial(int n) public void polynomial(int n, double fixedIntercept) public void polynomialPlot(int n) public void polynomialPlot(int n, double fixedIntercept) public void polynomialPlot(int n, String xLegend, String yLegend) public void polynomialPlot(int n, double fixedIntercept, String xLegend, String yLegend) public ArrayList

### CONSTRUCTORS

The Example Programs give several examples of non-linear regression using different constructors.

Errors in both the dependent and indpendent variables
public Regression(double[ ][ ] xdata, double[ ] ydata, double[ ][ ] xerrors, double[ ] yerrors)
public Regression(double[ ][ ] xdata, double[ ][ ] ydata, double[ ][ ] xerrors, double[ ][ ] yerrors)
public Regression(double[ ] xdata, double[ ] ydata, double[ ] xerrors, double[ ] yerrors)
public Regression(double[ ] xdata, double[ ][ ] ydata, double[ ] xerrors, double[ ][ ] yerrors)
public Regression(double[ ][ ] xdata, double[ ] ydata, double[ ] yerrors)
Usage:                      Regression reg = new Regression(xdata, ydata, xerors, yerrors)
Creates a new instance of Regression that allows the appropriate regression procedures, described below, to be performed on the data set, xdata, ydata, xerrors, yerrors, where:
ydata are the dependent variables; y may be a single or double dimension array, i.e. more than one set of dependent variable.
xdata are the independent variables; xdata may be:
• a one-dimensional array
•      e.g. fitting to a straight line, yi = a0 + a1.xi
e.g. fitting to a polynomial, yi = a0 + a1.xi + a2.xi2 + a3.xi3 + ...
• a multidimensional array
e.g. multiple linear regeression, yi = a0 + a1.x0i + a2.x1i + a3.x2i + ...
e.g. multiple non-linear regeression, yi = non-linear function of a0, a1, a2 etc. and x0,i, x1,i, x2,i etc.
xerrors and yerrors are the measurement errors in the independent variables (x) and in the dependent variable (y) respectively. In this usage these errors are combined to provide the weighting factors, wi [weight], as

i.e. assuming the errors are uncorrelated. xerrors and yerrors should contain the standard deviations or estimates of the standard deviations of the corresponding measurements in ydata and ydata respectively. If they are not entered as such, i.e. if the are entered as internally consisted weights that are not equal to estimates of the standard deviations, the method setErrorsAsScaled() must also be called.
As weights are provided in this usage chi square

is minimised, where the calculated y[] are obtained from the appropriate above equation.
If more than 40% of the elements of the array, yerror, are zero or negative all elements of the array are equated to unity, i.e. an unweighted regression is performed, i.e. ss,

is minimised, otherwise all zero or negative elements are replaced by the average of their nearest positive neighbours.

If the data is to be plotted after the regression has been performed the values in the entered data must be ordered as they will appear on the graph. See ArrayMaths() for methods of sorting one array into ascending order with the ordering of an accompanying array into the same order.
The number of methods that will handle errors in both coordinates is limited - see above. See below for constructors appropriate for unweighted or dependent variable only weighted data.

Errors only in the dependent variable
public Regression(double[ ][ ] xdata, double[ ][ ] ydata, double[ ][ ] yerrors)
public Regression(double[ ] xdata, double[ ] ydata, double[ ] yerrors)
public Regression(double[ ] xdata, double[ ][ ] ydata, double[ ][ ] yerrors)
Usage:                      Regression reg = new Regression(xdata, ydata, xerors, yerrors)
Creates a new instance of Regression that allows the appropriate regression procedures, described below, to be performed on the data set, xdata, ydata, yerrors, where:
ydata are the dependent variables; y may be a single or double dimension array, i.e. more than one set of dependent variable.
xdata are the independent variables; xdata may be:
• a one-dimensional array
•      e.g. fitting to a straight line, yi = a0 + a1.xi
e.g. fitting to a polynomial, yi = a0 + a1.xi + a2.xi2 + a3.xi3 + ...
• a multidimensional array
e.g. multiple linear regeression, yi = a0 + a1.x0i + a2.x1i + a3.x2i + ...
e.g. multiple non-linear regeression, yi = non-linear function of a0, a1, a2 etc. and x0,i, x1,i, x2,i etc.
yerrors are the measurement errors in the dependent variable, y, and in this usage are used as the weighting factors, weight. These should be the standard deviations or estimates of the standard deviations of the corresponding measurements in ydata. If they are not entered as such, i.e. if the are entered as internally consisted weights that are not equal to estimates of the standard deviations, the method setErrorsAsScaled() must also be called.

As weights are provided in this usage chi square

is minimised, where the calculated y[] are obtained from the appropriate above equation.
If more than 40% of the elements of the array, yerror, are zero or negative all elements of the array are equated to unity, i.e. an unweighted regression is performed, i.e. ss,

is minimised, otherwise all zero or negative elements are replaced by the average of their nearest positive neighbours.

If the data is to be plotted after the regression has been performed the values in the entered data must be ordered as they will appear on the graph. See ArrayMaths() for methods of sorting one array into ascending order with the ordering of an accompanying array into the same order.
All the regression methods will handle data in which only dependent variable errors are used.

Unweighted regressions
public Regression(double[ ][ ] xdata, double[ ] ydata)
public Regression(double[ ][ ] xdata, double[ ][ ] ydata)
public Regression(double[ ] xdata, double[ ] ydata)
public Regression(double[ ] xdata, double[ ][ ] ydata)
Usage:                      Regression reg = new Regression(xdata, ydata)
Creates a new instance of Regression that allows the appropriate regression procedures, described below, to be performed on the data set, xdata, ydata, where:
ydata are the dependent variables; y may only be a single or double dimension array, i.e. more than one set of dependent variable.
xdata are the independent variables; xdata may be a one-dimensional array or a multidimensional array (multiple rgeression) [as above].
As the weighting factor array weight is not provided in these constructors, all weighting factors are all equated to unity, i.e. an unweighted regression is performed.
All the regression methods will handle unweighted data.

Binned data
public Regression(double[ ] xdata, double binWidth, double binWidth)
public Regression(double[ ] xdata, double binWidth)
Usage:                      Regression reg = new Regression(xdata, binWidth, binZero)
Creates a new instance of Regression that first bins the data in the array, xdata in the above usage, into a set of frequency bins of width, binWidth in the above usage, with the first bin starting at binZero in the above usage. It then allows the appropriate regression procedures, described below, to be performed on the binned data set. Treats the data as unscaled true frequencies, see Data Type below.

Usage:                      Regression reg = new Regression(xdata, binWidth)
Creates a new instance of Regression that first bins the data in the array, xdata in the above usage, into a set of frequency bins of width, binWidth, in the above usage. The start of the bins in calculated, within this method, to encompass all the data. It then allows the appropriate regression procedures, described below, to be performed on the binned data set. Treats the data as unscaled true frequencies, see Data Type below.

### METHODS

LINEAR REGRESSION
Fitting to a constant
public void constant()
public void constantPlot()
public void constantPlot(String xLegend, String yLegend)
Usage:                      reg.constant();
Fits the data supplied, via the constructor, to the instance reg in the above usage, to the linear equation
yi = a0
See below, or summary table above, for methods to obtain
• best estimates of the coefficient
• estimates of their standard deviation
• t-values
• p-values
• calculated y values
• residuals
• sum of squares of residuals
Usage:                      reg.constantPlot();
Performs all that is described above under reg.constant() and in addition
• displays a plot of the data and best fit line
• outputs a text file of best estimates of the coefficients and their standard deviations, t-values, p-values, observed and calculated data values and the regression statistics (see print for detailed output list). The output of this file can be suppressed (see suppressPrint()).
Usage:                      reg.constantPlot(xLegend, yLegend);
Performs all that is described above under reg.constantPlot() and in addition adds the x-axis (abscissa) legend, xLegend, and the y-axis (ordinate) legend, yLegend, to the plot.

Linear with intercept: intercept to be found by regression
See below for regression with a fixed intercept
public void linear()
public void linearPlot()
public void linearPlot(String xLegend, String yLegend)
Usage:                      reg.linear();
Fits the data supplied, via the constructor, to the instance reg in the above usage, to the linear equation
yi = a0 + a1.x0,i + a2.x1,i + ...
See below, or summary table above, for methods to obtain
• best estimates of the coefficients
• estimates of their standard deviations
• estimate of the covariance matrix
• t-values
• p-values
• correlation coefficients
• calculated y values
• residuals
• sum of squares of residuals
• chi square (if weigths or true frequencies provided)
Usage:                      reg.linearPlot();
Performs all that is described above under reg.linear() and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed y values versus the calculated y values. This plot can be suppressed (see suppressYYplot()).
• outputs a text file of best estimates of the coefficients and their standard deviations, t-valus, p-values, observed and calculated data values and the regression statistics. The output of this file can be suppressed (see suppressPrint()).
Usage:                      reg.linearPlot(xLegend, yLegend);
Performs all that is described above under reg.linearPlot() and in addition adds the x-axis (abscissa) legend, xLegend, and the y-axis (ordinate) legend, yLegend, to the plot.

Linear with a fixed intercept
See above for regression with intercept found by the regression.
public void linear(double fixedIntercept)
public void linearPlot(double fixedIntercept)
public void linearPlot(double fixedIntercept, String xLegend, String yLegend)
Usage:                      reg.linear(fixedIntercept);
Fits the data supplied, via the constructor, to the instance reg in the above usage, to the linear equation
yi = a0 + a1.x0,i + a2.x1,i + ...
with the value of the intercept, a0, fixed at the value supplied as the argument, fixedIntercept.
The best estimates of a1, a2 ... etc are returned by methods returning the best estimate array, i.e. a0 is not returned in the best estimates array as its value has been fixed.
• best estimates of the coefficients
• estimates of their standard deviations
• estimate of the covariance matrix
• t-values
• p-values
• correlation coefficients
• calculated y values
• residuals
• sum of squares of residuals
• chi square (if weigths or true frequencies provided)
• Usage:                      reg.linearPlot(fixedIntercept);
Performs all that is described above under reg.linear(fixedIntercept) and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed y values versus the calculated y values. This plot can be suppressed (see suppressYYplot()).
• outputs a text file of best estimates of the coefficients and their standard deviations, t-values, p-values, observed and calculated data values and the regression statistics (see print for detailed output list). The output of this file can be suppressed (see suppressPrint()).
Usage:                      reg.linearPlot(fixedIntercept, xLegend, yLegend);
Performs all that is described above under reg.linearPlot(fixedIntercept) and in addition adds the x-axis (abscissa) legend, xLegend, and the y-axis (ordinate) legend, yLegend, to the plot.

General Linear Regression
public void linearGeneral()
public void linearGeneralPlot()
public void linearGeneralPlot(String xLegend, String yLegend)
Usage:                      reg.linearGeneral();
Fits the data supplied, via the constructor, to the instance reg in the above usage, to the linear equation
yi = a linear function of the the coefficients, a0, a1, a2 etc. and the independent variables, x0,i, x1,i, x2,i etc
e.g. yi = a0.x0,i + a1.x1,i + ...
See below, or summary table above, for methods to obtain
• best estimates of the coefficients
• estimates of their standard deviations
• t-values
• p-values
• estimate of the covariance matrix
• correlation coefficients between estimated parameters
• calculated y values
• residuals
• sum of squares of residuals
• chi square (if weigths or true frequencies provided)
• correlation coefficient between x(experimental) and y(experimental)
• correlation coefficient between y(experimental) and y(calculated)
• coefficient of determination
• correlation coefficient between y(experimental) and y(calculated) calculated as:

Usage:                      reg.linearGeneralPlot();
Performs all that is described above under reg.linearGeneral() and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed y values versus the calculated y values. This plot can be suppressed (see suppressYYplot()).
• outputs a text file of best estimates of the coefficients and their standard deviations, t-values, p-values, observed and calculated data values and the regression statistics (see print for detailed output list). The output of this file can be suppressed (see suppressPrint()).
Usage:                      reg.linearGeneralPlot(xLegend, yLegend);
Performs all that is described above under reg.linearGeneralPlot() and in addition adds the x-axis (abscissa) legend, xLegend, and the y-axis (ordinate) legend, yLegend, to the plot.

Fitting to a polynomial of known degree: intercept found by regression
See fixed intercept fitting (below) for polynomial fitting with a fixed intercept.
Also see best polynomial (below) for finding the polynomial and its degree that gives the best fit.

public void polynomial(int deg)
public void polynomialPlot(int deg)
public void polynomialPlot(int deg, String xLegend, String yLegend)

Usage:                      reg.polynomial(deg);
Fits the data supplied, via the constructor taking a one dimensional array of the independent variable values, to the instance reg in the above usage, to a polynomial of degree, n, transferred as the method argument (deg in the above usage)

See below, or summary table above, for methods to obtain
• best estimates of the coefficients
• estimates of their standard deviations
• t-values
• p-values
• estimate of the covariance matrix
• correlation coefficients between estimated parameters
• calculated y values
• residuals
• sum of squares of residuals
• chi square (if weigths or true frequencies provided)
• correlation coefficient between x(experimental) and y(experimental)
• correlation coefficient between y(experimental) and y(calculated)
• coefficient of determination
• adjusted coefficient of determination

Usage:                      reg.polynomialPlot(deg);
Performs all that is described above under reg.polynomial(deg) and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed y values versus the calculated y values. This plot can be suppressed (see suppressYYplot()).
• outputs a text file of best estimates of the coefficients and their standard deviations, t-values, p-values, observed and calculated data values and the regression statistics (see print for detailed output list). The output of this file can be suppressed (see suppressPrint()).
Usage:                      reg.polynomialPlot(deg, xLegend, yLegend);
Performs all that is described above under reg.polynomialPlot(deg) and in addition adds the x-axis (abscissa) legend, xLegend, and the y-axis (ordinate) legend, yLegend, to the plot.

Fitting to a polynomial of known degree with a fixed intercept
See above for polynomial fitting with the intercept included in the regression.
Also see best polynomial [fixed intercept] (below) for finding the polynomial, with a fixed intercept, and its degree that gives the best fit.

public void polynomial(int n, double fixedIntercept)
public void polynomialPlot(int n, double fixedIntercept)
public void polynomialPlot(int n, double fixedIntercept, String xLegend, String yLegend)
Usage:                      reg.polynomial(deg, fixedIntercept);
Fits the data supplied, via the constructor taking a one dimensional array of the independent variable values, to the instance reg in the above usage, to a polynomial of degree, n, transferred as the method argument (deg in the above usage)

with the value of the intercept, a0, fixed at the value supplied as the argument, fixedIntercept.
The best estimates of a1 to an are returned by methods returning the best estimate array, i.e. a0 is not returned in the best estimates array as its value has been fixed.
See below, or summary table above, for methods to obtain
• best estimates of the coefficients
• estimates of their standard deviations
• t-values
• p-values
• estimate of the covariance matrix
• correlation coefficients between estimated parameters
• calculated y values
• residuals
• sum of squares of residuals
• chi square (if weigths or true frequencies provided)
• correlation coefficient, r, between x(experimental) and y(experimental)
• correlation coefficient, r, between y(experimental) and y(calculated)
• coefficient of determination

Usage:                      reg.polynomialPlot(deg, fixedIntercept);
Performs all that is described above under reg.polynomial(deg, fixedIntercept) and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed y values versus the calculated y values. This plot can be suppressed (see suppressYYplot()).
• outputs a text file of best estimates of the coefficients and their standard deviations, t-valus, p-values, observed and calculated data values and the regression statistics. The output of this file can be suppressed (see suppressPrint()).
Usage:                      reg.polynomialPlot(deg, fixedIntercept, xLegend, yLegend);
Performs all that is described above under reg.polynomialPlot(deg, fixedIntercept) and in addition adds the x-axis (abscissa) legend, xLegend, and the y-axis (ordinate) legend, yLegend, to the plot.

Fitting to a polynomial of unknown degree and unknown intercept
See best polynomial [fixed intercept] (below) for finding the polynomial, with a fixed intercept, and its degree that gives the best fit.

public ArrayList<Object> bestPolynomial()
public ArrayList<Object> bestPolynomialPlot()
public ArrayList<Object> bestPolynomialPlot(String xLegend, String yLegend)

Usage:                      arrayl = reg.bestPolynomial();
Fits the data supplied, via the constructor taking a one dimensional array of the independent variable values, to the instance reg in the above usage, to polynomials of increasing degree starting at zero degree, i.e. a constant. The polynomial that provides the best fit is determined by an additional term F-test (See below for details of this test). A significance probability level of 0.05 is used in this test but this level may be changed (see setFtestSignificance). A full analysis is then performed on the best fit polynomial as described under fitPolynomial(n) above.
The returned ArrayList, arrayl, contains:
• The degree of the best fit polynomial (Integer)
• The number of pair wise comparisons made (Integer)
• The int[] array of the degree of the first polynomial in each pair wise comparison
• The int[] array of the degree of the second polynomial in each pair wise comparison
• The double[] array of the chi square or sum of squares of the first polynomial fit in each pair wise comparison
• The double[] array of the chi square or sum of squares of the second polynomial fit in each pair wise comparison
• The double[] array of the F-ratios for each comparison
• The double[] array of the F-ratio probabilities for each comparison
• The double[] array of the F-ratio values at the chosen significance level for each comparison
• The value of the chosen significance level
Usage:                      arrayl = reg.bestPolynomialPlot();
Performs all that is described above under reg.bestPolynomial() and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed y values versus the calculated y values. This plot can be suppressed (see suppressYYplot()).
• outputs a text file, called BestPolynomialOutput, of best estimates of the coefficients and their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and search details (see print for detailed output list). The output of this file can be suppressed (see suppressPrint()).
Usage:                      reg.bestPolynomialPlot(xLegend, yLegend);
Performs all that is described above under reg.bestPolynomialPlot() and in addition adds the x-axis (abscissa) legend, xLegend, and the y-axis (ordinate) legend, yLegend, to the plot.

Fitting to a polynomial of unknown degree and fixed intercept
See best polynomial (above) for finding the polynomial, with a unknown intercept, and its degree that gives the best fit.

public ArrayList<Object> bestPolynomial(double fixedIntercept)
public ArrayList<Object> bestPolynomialPlot(double fixedIntercept)
public ArrayList<Object> bestPolynomialPlot(double fixedIntercept, String xLegend, String yLegend)

Usage:                      arrayl = reg.bestPolynomial(fixedIntercept);
Fits the data supplied, via the constructor taking a one dimensional array of the independent variable values, to the instance reg in the above usage, to polynomials, with a fixed intercept (fixedIntercept) of increasing degree starting at a degree of one. The polynomial that provides the best fit is determined by an additional term F-test (See below for details of this test). A significance probability level of 0.05 is used in this test but this level may be changed (see setFtestSignificance). A full analysis is then performed on the best fit polynomial as described under fitPolynomial(n) above.
The returned ArrayList, arrayl, contains:
• The degree of the best fit polynomial (Integer)
• The number of pair wise comparisons made (Integer)
• The int[] array of the degree of the first polynomial in each pair wise comparison
• The int[] array of the degree of the second polynomial in each pair wise comparison
• The double[] array of the chi square or sum of squares of the first polynomial fit in each pair wise comparison
• The double[] array of the chi square or sum of squares of the second polynomial fit in each pair wise comparison
• The double[] array of the F-ratios for each comparison
• The double[] array of the F-ratio probabilities for each comparison
• The double[] array of the F-ratio values at the chosen significance level for each comparison
• The value of the chosen significance level
Usage:                      arrayl = reg.bestPolynomialPlot(fixedIntercept);
Performs all that is described above under reg.bestPolynomial(fixedIntercept) and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed y values versus the calculated y values. This plot can be suppressed (see suppressYYplot()).
• outputs a text file of best estimates of the coefficients and their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and search details (see print for detailed output list). The output of this file can be suppressed (see suppressPrint()).
Usage:                      reg.bestPolynomialPlot(fixedIntercept, xLegend, yLegend);
Performs all that is described above under reg.bestPolynomialPlot(fixedIntercept) and in addition adds the x-axis (abscissa) legend, xLegend, and the y-axis (ordinate) legend, yLegend, to the plot.

Resetting the F-test significance level
public void setFtestSignificance(double signif)
public double getFtestSignificance()
Usage:                      reg.setFtestSignificance(signif);
Resets the F-test significance level, as described in the method above (bestPolynomial), to the value passed as the argument, signif. The default value is 0.05.

Usage:                      signif = reg.getFtestSignificance();
Returns the F-test significance level described in the method above (bestPolynomial). The default value is 0.05.

Fitting to a non-integer polynomial
See also ImmunoAssay.
public void nonIntegerPolynomial(int nTerms)
public void nonIntegerPolynomialPlot(int nTerms)
public void nonIntegerPolynomialPlot(int nTerms, String xLegend, String yLegend)
Usage:                      reg.nonIntegerPolynomial(nTerms);
This method fits the data supplied, via the constructor taking a one dimensional array of the independent variable values, to the instance reg in the above usage, to a non-integer polynomial

where the number of terms, argument nTerms, equals n+1. The best estimates of all the ai may all take non-integer values and are determined by non-linear regression as described below.

Usage:                      reg.nonIntegerPolynomialPlot(nTerms);
Performs all that is described above under reg.nonIntegerPolynomial(nTerms)
and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed y values versus the calculated y values
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list).
Usage:                      reg.nonIntegerPolynomialPlot(nTerms, xLegend, yLegend);
Performs all that is described above under reg.nonIntegerPolynomialPlot(). The legends on the plot will be those passed as this method's arguments.

NON-LINEAR REGRESSION
WARNING:
If you do not have an understanding of the basis of non-linear regression you are strongly advised to read a good text-book on non-linear regression before using the non-linear regression methods of this library.
Non-linear rgression procedures may often exit having found a local or a false minimum in the sum of squares of residuals surface rather than at the global minimum hence giving false best estimates. You should always check a plot of the experimental data and the calculated best fit curve.
It is a common practice to repeat non-linear regressions using a new set of initial estimates calculated as
new initial estimate = (two times the original initial estimate) minus the best estimate value
i.e. equidistant to the initial estimate/best estimate distance but on the opposite side of the initial estimate.
The statistical output should also be checked but should also be treated with great caution. The statistical parameters, e.g. best estimate error, are calculated using the approach that is strictly only valid for linear models, i.e. in linear regression. The assumption that must be satisfied for these statistics to be anyway meaningful in non-linear regression is that the sum of squares of residuals surface is a quadratic surface in the region of the minimum. This approximation is often valid but far from always.

Nelder and Mead Simplex Method
This method implements the Nelder and Mead heuristic simplex optimization procedure to minimise either chi square
(if weights provided)
or the summ of squares
(if no weights provided)
for the data supplied, via the constructor, to the instance of Regression (reg in the above and below usage) and a user supplied function (see below).
The Example Programs give several examples of non-linear regression.
Reference: Nelder, J.A. and Mead, R. (1965) Computer Journal, 7, 308-313.

methods
public void simplex(RegressionFunction rf, double[ ] start, double[ ] step, double ftol, int nmax)
public void simplex(RegressionFunction2 rf, double[ ] start, double[ ] step, double ftol, int nmax)
public void simplex(RegressionFunction3 rf, double[ ] start, double[ ] step, double ftol, int nmax)
Usage:                      reg.simplex(rf, start, step, ftol, nmax);
Fits the data supplied, via the constructor, to the instance reg in the above usage, to a function coded in a Regression Function; rf in the above usage. The procedure for coding the function, rf, is described in detail
below and is illustrated in the Example Programs.

The array, start, holds the initial estimates of the parameters whose best estimates are required.

The array, step, holds the initial step sizes for each of the parameters. These step sizes are used to construct the initial simplex. They may differ for each parameter and should reflect, if known, the uncertainty in the initial estimates. This argument is optional [see below]

The double, ftol, is the tolerance used in determining the convergence of the regression. This argument is optional [see below]
The regression may be terminated by one of two procedures:
1. terminate if the standard deviation of the sum of squares [unweighted data] or of the chi square values [weighted data] at the apices of the simplex is less than the tolerance, ftol [this is the default option].
2. terminate if the reduced chi square [weighted data] or the reduced sum of squares [unweighted data] at the lowest apex of the simplex is less than the mean of the absolute values of the dependent variable (y values) multiplied by the tolerance, ftol.
The default procedure is procedure 1 above with a default value of ftol of 1.0e-9. The default option may be overridden by the method setMintest().

The integer, nmax, is the maximum number of iterations allowed by the simplex procedure. This argument is optional [see below]. If the maximum number of iterations is reached the method returns the current estimates at that point in the iteration.

The second differentials needed in the calculation of the covariance matrix, used in calculation of the estimates of the errors of the best estimates, are calculated by numerical differencing if this method is called. See below for a method that allows the derivatives to be calculated analytically.

See below, or summary table above, for methods to obtain
• best estimates of the coefficients
• 'linear approximation' of their standard deviations
• 'linear approximation' of their t-values
• 'linear approximation' of their p-values
• 'linear approximation' of the covariance matrix
• 'linear approximation' of the correlation coefficients between estimated parameters
• calculated y values
• residuals
• sum of squares of residuals
• chi square (if weigths or true frequencies provided)
• correlation coefficient, r, between x(experimental) and y(experimental)
• correlation coefficient, r, between y(experimental) and y(calculated)
• coefficient of determination
• adjusted coefficient of determination
• simplex termination details

• public void simplex(RegressionFunction rf, RegressionDerivativeFunction rdf, double[ ] start, double[ ] step, double ftol, int nmax)
public void simplex(RegressionFunction2 rf, RegressionDerivativeFunction2 rdf, double[ ] start, double[ ] step, double ftol, int nmax)
public void simplex(RegressionFunction3 rf, RegressionDerivativeFunction rdf, double[ ] start, double[ ] step, double ftol, int nmax)
public void simplex(RegressionFunction3 rf, RegressionDerivativeFunction2 rdf, double[ ] start, double[ ] step, double ftol, int nmax)
Usage:                      reg.simplex(rf, rfd, start, step, ftol, nmax);
This method performs all the actions described under
reg.simplex(rf, start, step, ftol, nmax), immediately above, with the exception that the second differentials needed in the calculation of the covariance matrix, used in calculation of the estimates of the errors of the best estimates, are calculated analytically. The first and second derivatives of the function being fitted with respect to pairs of parameters must be coded within a method in a Regression Derivative Function; rdf in the above usage. Detailed Instructions on coding this function are given below and illustrated in the Example Program illustrating the use of ReferenceDerivativeFunction. See above for a method that allows the derivatives to be calculated numerically.

public void simplexPlot(RegressionFunction rf, double[ ] start, double[ ] step, double ftol, int nmax)
public void simplexPlot(RegressionFunction2 rf, double[ ] start, double[ ] step, double ftol, int nmax)
public void simplexPlot(RegressionFunction3 rf, double[ ] start, double[ ] step, double ftol, int nmax)
Usage:                      reg.simplexPlot(rf, start, step, ftol, nmax);
Performs all that is described above under
reg.simplex(rf, start, step, ftol, nmax) and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed y values versus the calculated y values. This plot can be suppressed (see suppressYYplot()).
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list). The output of this file can be suppressed (see suppressPrint()).

public void simplexPlot(RegressionFunction rf, RegressionDerivativeFunction rdf, double[ ] start, double[ ] step, double ftol, int nmax)
public void simplexPlot(RegressionFunction2 rf, RegressionDerivativeFunction2 rdf, double[ ] start, double[ ] step, double ftol, int nmax)
public void simplexPlot(RegressionFunction3 rf, RegressionDerivativeFunction rdf, double[ ] start, double[ ] step, double ftol, int nmax)
public void simplexPlot(RegressionFunction3 rf, RegressionDerivativeFunction2 rdf, double[ ] start, double[ ] step, double ftol, int nmax)
Usage:                      reg.simplexPlot(rf, rfd, start, step, ftol, nmax);
Performs all that is described above under
reg.simplex(rf, rfd, start, step, ftol, nmax) and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed y values versus the calculated y values. This plot can be suppressed (see suppressYYplot()).
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list). The output of this file can be suppressed (see suppressPrint()).

public void simplex(RegressionFunction rf, double[ ] start, double[ ] step, double ftol)
public void simplex(RegressionFunction2 rf, double[ ] start, double[ ] step, double ftol)
public void simplex(RegressionFunction3 rf, double[ ] start, double[ ] step, double ftol)
Usage:                      reg.simplex(rf, start, step, ftol);
As reg.simplex(rf, start, step, ftol, nmax) above with the exception that the maximum number of iterations is not provided as an argument. A default value of 3000 is used.

public void simplex(RegressionFunction rf, RegressionDerivativeFunction rdf, double[ ] start, double[ ] step, double ftol)
public void simplex(RegressionFunction2 rf, RegressionDerivativeFunction2 rdf, double[ ] start, double[ ] step, double ftol)
public void simplex(RegressionFunction3 rf, RegressionDerivativeFunction rdf, double[ ] start, double[ ] step, double ftol)
public void simplex(RegressionFunction3 rf, RegressionDerivativeFunction2 rdf, double[ ] start, double[ ] step, double ftol)
Usage:                      reg.simplex(rf, rfd, start, step, ftol);
As reg.simplex(rf, rfd, start, step, ftol, nmax) above with the exception that the maximum number of iterations is not provided as an argument. A default value of 3000 is used.

public void simplexPlot(RegressionFunction rf, double[ ] start, double[ ] step, double ftol)
public void simplexPlot(RegressionFunction2 rf, double[ ] start, double[ ] step, double ftol)
public void simplexPlot(RegressionFunction3 rf, double[ ] start, double[ ] step, double ftol)
Usage:                      reg.simplexPlot(rf, start, step, ftol);
Performs all that is described above under reg.simplex(rf, start, step, ftol) and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed y values versus the calculated y values. This plot can be suppressed (see suppressYYplot()).
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list). The output of this file can be suppressed (see suppressPrint()).
public void simplexPlot(RegressionFunction rf, RegressionDerivativeFunction rdf, double[ ] start, double[ ] step, double ftol)
public void simplexPlot(RegressionFunction2 rf, RegressionDerivativeFunction2 rdf, double[ ] start, double[ ] step, double ftol)
public void simplexPlot(RegressionFunction3 rf, RegressionDerivativeFunction rdf, double[ ] start, double[ ] step, double ftol)
public void simplexPlot(RegressionFunction3 rf, RegressionDerivativeFunction2 rdf, double[ ] start, double[ ] step, double ftol)
Usage:                      reg.simplexPlot(rf, rfd, start, step, ftol);
Performs all that is described above under reg.simplex(rf, rfd, start, step, ftol) and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed y values versus the calculated y values. This plot can be suppressed (see suppressYYplot()).
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list). The output of this file can be suppressed (see suppressPrint()).

public void simplex(RegressionFunction rf, double[ ] start, double[ ] step, int nmax)
public void simplex(RegressionFunction2 rf, double[ ] start, double[ ] step, int nmax)
public void simplex(RegressionFunction3 rf, double[ ] start, double[ ] step, int nmax)
Usage:                      reg.simplex(rf, start, step, nmax);
As reg.simplex(rf, start, step, ftol, nmax) above with the exception that the terrmination tolerance is not provided as an argument. A default value of 1e-9 is used.

public void simplex(RegressionFunction rf, RegressionDerivativeFunction rfd, double[ ] start, double[ ] step, int nmax)
public void simplex(RegressionFunction2 rf, RegressionDerivativeFunction2 rfd, double[ ] start, double[ ] step, int nmax)
public void simplex(RegressionFunction3 rf, RegressionDerivativeFunction rfd, double[ ] start, double[ ] step, int nmax)
public void simplex(RegressionFunction3 rf, RegressionDerivativeFunction2 rfd, double[ ] start, double[ ] step, int nmax)
Usage:                      reg.simplex(rf, rfd, start, step, nmax);
As reg.simplex(rf, rfd, start, step, ftol, nmax) above with the exception that the terrmination tolerance is not provided as an argument. A default value of 1e-9 is used.

public void simplexPlot(RegressionFunction rf, double[ ] start, double[ ] step, int nmax)
public void simplexPlot(RegressionFunction2 rf, double[ ] start, double[ ] step, int nmax)
public void simplexPlot(RegressionFunction3 rf, double[ ] start, double[ ] step, int nmax)
Usage:                      reg.simplexPlot(rf, start, step, nmax);
Performs all that is described above under reg.simplex(rf, start, step, nmax) and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed y values versus the calculated y values. This plot can be suppressed (see suppressYYplot()).
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list). The output of this file can be suppressed (see suppressPrint()).
public void simplexPlot(RegressionFunction rf, RegressionDerivativeFunction rfd, double[ ] start, double[ ] step, int nmax)
public void simplexPlot(RegressionFunction2 rf, RegressionDerivativeFunction2 rfd, double[ ] start, double[ ] step, int nmax)
public void simplexPlot(RegressionFunction3 rf, RegressionDerivativeFunction rfd, double[ ] start, double[ ] step, int nmax)
public void simplexPlot(RegressionFunction3 rf, RegressionDerivativeFunction2 rfd, double[ ] start, double[ ] step, int nmax)
Usage:                      reg.simplexPlot(rf, rfd, start, step, nmax);
Performs all that is described above under reg.simplex(rf, rfd, start, step, nmax) and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed y values versus the calculated y values. This plot can be suppressed (see suppressYYplot()).
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list). The output of this file can be suppressed (see suppressPrint()).

public void simplex(RegressionFunction rf, double[ ] start, double ftol, int nmax)
public void simplex(RegressionFunction2 rf, double[ ] start, double ftol, int nmax)
public void simplex(RegressionFunction3 rf, double[ ] start, double ftol, int nmax)
Usage:                      reg.simplex(rf, start, ftol, nmax);
As reg.simplex(rf, start, step, ftol, nmax) above with the exception that the initial simplex step values are not provided as an argument. A default value of 0.5 times the corresponing initial estimate [start] is used for the steps for all parameters.

public void simplex(RegressionFunction rf, RegressionDerivativeFunction rdf, double[ ] start, double ftol, int nmax)
public void simplex(RegressionFunction2 rf, RegressionDerivativeFunction2 rdf, double[ ] start, double ftol, int nmax)
public void simplex(RegressionFunction3 rf, RegressionDerivativeFunction rdf, double[ ] start, double ftol, int nmax)
public void simplex(RegressionFunction3 rf, RegressionDerivativeFunction2 rdf, double[ ] start, double ftol, int nmax)
Usage:                      reg.simplex(rf, rfd, start, ftol, nmax);
As reg.simplex(rf, rfd, start, step, ftol, nmax) above with the exception that the initial simplex step values are not provided as an argument. A default value of 0.5 times the corresponing initial estimate [start] is used for the steps for all parameters.

public void simplexPlot(RegressionFunction rf, double[ ] start, double ftol, int nmax)
public void simplexPlot(RegressionFunction2 rf, double[ ] start, double ftol, int nmax)
public void simplexPlot(RegressionFunction3 rf, double[ ] start, double ftol, int nmax)
Usage:                      reg.simplexPlot(rf, start, ftol, nmax);
Performs all that is described above under reg.simplex(rf, start, ftol, nmax) and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed y values versus the calculated y values. This plot can be suppressed (see suppressYYplot()).
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list). The output of this file can be suppressed (see suppressPrint()).
public void simplexPlot(RegressionFunction rf, RegressionDerivativeFunction rdf, double[ ] start, double ftol, int nmax)
public void simplexPlot(RegressionFunction2 rf, RegressionDerivativeFunction2 rdf, double[ ] start, double ftol, int nmax)
public void simplexPlot(RegressionFunction3 rf, RegressionDerivativeFunction rdf, double[ ] start, double ftol, int nmax)
public void simplexPlot(RegressionFunction3 rf, RegressionDerivativeFunction2 rdf, double[ ] start, double ftol, int nmax)
Usage:                      reg.simplexPlot(rf, rfd, start, ftol, nmax);
Performs all that is described above under reg.simplex(rf, rfd, start, ftol, nmax) and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed y values versus the calculated y values. This plot can be suppressed (see suppressYYplot()).
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list). The output of this file can be suppressed (see suppressPrint()).

public void simplex(RegressionFunction rf, double[ ] start, double[ ] step, double ftol)
public void simplex(RegressionFunction2 rf, double[ ] start, double[ ] step, double ftol)
public void simplex(RegressionFunction3 rf, double[ ] start, double[ ] step, double ftol)
Usage:                      reg.simplex(rf, start, step, ftol);
As reg.simplex(rf, start, step, ftol, nmax) above with the exception that the maximum number of iterations is not provided as an argument. A default value of 3000 is used.

public void simplex(RegressionFunction rf, RegressionDerivativeFunction rdf, double[ ] start, double[ ] step, double ftol)
public void simplex(RegressionFunction2 rf, RegressionDerivativeFunction2 rdf, double[ ] start, double[ ] step, double ftol)
public void simplex(RegressionFunction3 rf, RegressionDerivativeFunction rdf, double[ ] start, double[ ] step, double ftol)
public void simplex(RegressionFunction3 rf, RegressionDerivativeFunction2 rdf, double[ ] start, double[ ] step, double ftol)
Usage:                      reg.simplex(rf, rfd, start, step, ftol);
As reg.simplex(rf, rfd, start, step, ftol, nmax) above with the exception that the maximum number of iterations is not provided as an argument. A default value of 3000 is used.

public void simplexPlot(RegressionFunction rf, double[ ] start, double[ ] step, double ftol)
public void simplexPlot(RegressionFunction2 rf, double[ ] start, double[ ] step, double ftol)
public void simplexPlot(RegressionFunction3 rf, double[ ] start, double[ ] step, double ftol)
Usage:                      reg.simplexPlot(rf, start, step, ftol);
Performs all that is described above under reg.simplex(rf, start, step, ftol) and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed y values versus the calculated y values. This plot can be suppressed (see suppressYYplot()).
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list). The output of this file can be suppressed (see suppressPrint()).
public void simplexPlot(RegressionFunction rf, RegressionDerivativeFunction rdf, double[ ] start, double[ ] step, double ftol)
public void simplexPlot(RegressionFunction2 rf, RegressionDerivativeFunction2 rdf, double[ ] start, double[ ] step, double ftol)
public void simplexPlot(RegressionFunction3 rf, RegressionDerivativeFunction rdf, double[ ] start, double[ ] step, double ftol)
public void simplexPlot(RegressionFunction3 rf, RegressionDerivativeFunction2 rdf, double[ ] start, double[ ] step, double ftol)
Usage:                      reg.simplexPlot(rf, rfd, start, step, ftol);
Performs all that is described above under reg.simplex(rf, rfd, start, step, ftol) and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed y values versus the calculated y values. This plot can be suppressed (see suppressYYplot()).
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list). The output of this file can be suppressed (see suppressPrint()).

public void simplex(RegressionFunction rf, double[ ] start, double[ ] step)
public void simplex(RegressionFunction2 rf, double[ ] start, double[ ] step)
public void simplex(RegressionFunction3 rf, double[ ] start, double[ ] step)
Usage:                      reg.simplex(rf, start, step);
As reg.simplex(rf, start, step, ftol, nmax) above with the exception that the maximum number of iterations and the termination tolerance are not provided as arguments. Default values of 1e-9 and 3000 respectively are used.

public void simplex(RegressionFunction rf, RegressionDerivativeFunction rdf, double[ ] start, double[ ] step)
public void simplex(RegressionFunction2 rf, RegressionDerivativeFunction2 rdf, double[ ] start, double[ ] step)
public void simplex(RegressionFunction3 rf, RegressionDerivativeFunction rdf, double[ ] start, double[ ] step)
public void simplex(RegressionFunction3 rf, RegressionDerivativeFunction2 rdf, double[ ] start, double[ ] step)
Usage:                      reg.simplex(rf, rfd, start, step);
As reg.simplex(rf, rfd,start, step, ftol, nmax) above with the exception that the maximum number of iterations and the termination tolerance are not provided as arguments. Default values of 1e-9 and 3000 respectively are used.

public void simplexPlot(RegressionFunction rf, double[ ] start, double[ ] step)
public void simplexPlot(RegressionFunction2 rf, double[ ] start, double[ ] step)
public void simplexPlot(RegressionFunction3 rf, double[ ] start, double[ ] step)
Usage:                      reg.simplexPlot(rf, start, step);
Performs all that is described above under reg.simplex(rf, start, step) and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed y values versus the calculated y values. This plot can be suppressed (see suppressYYplot()).
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list). The output of this file can be suppressed (see suppressPrint()).

public void simplexPlot(RegressionFunction rf, RegressionDerivativeFunction rdf, double[ ] start, double[ ] step)
public void simplexPlot(RegressionFunction2 rf, RegressionDerivativeFunction2 rdf, double[ ] start, double[ ] step)
public void simplexPlot(RegressionFunction3 rf, RegressionDerivativeFunction rdf, double[ ] start, double[ ] step)
public void simplexPlot(RegressionFunction3 rf, RegressionDerivativeFunction2 rdf, double[ ] start, double[ ] step)
Usage:                      reg.simplexPlot(rf, rfd, start, step);
Performs all that is described above under reg.simplex(rf, rfd, start, step) and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed y values versus the calculated y values. This plot can be suppressed (see suppressYYplot()).
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list). The output of this file can be suppressed (see suppressPrint()).

public void simplex(RegressionFunction rf, double[ ] start, double ftol)
public void simplex(RegressionFunction2 rf, double[ ] start, double ftol)
public void simplex(RegressionFunction3 rf, double[ ] start, double ftol)
Usage:                      reg.simplex(rf, start, ftol);
As reg.simplex(rf, start, step, ftol, nmax) above with the exception that the initial simplex step sizes and the maximum number of iterations are not provided as arguments. Default values of 0.5 times the corresponing initial estimate [start] for all parameters and 3000 respectively are used.

public void simplex(RegressionFunction rf, RegressionDerivativeFunction rdf, double[ ] start, double ftol)
public void simplex(RegressionFunction2 rf, RegressionDerivativeFunction2 rdf, double[ ] start, double ftol)
public void simplex(RegressionFunction3 rf, RegressionDerivativeFunction rdf, double[ ] start, double ftol)
public void simplex(RegressionFunction3 rf, RegressionDerivativeFunction2 rdf, double[ ] start, double ftol)
Usage:                      reg.simplex(rf, rfd, start, ftol);
As reg.simplex(rf, rfd, start, step, ftol, nmax) above with the exception that the initial simplex step sizes and the maximum number of iterations are not provided as arguments. Default values of 0.5 times the corresponing initial estimate [start] for all parameters and 3000 respectively are used.

public void simplexPlot(RegressionFunction rf, double[ ] start, double ftol)
public void simplexPlot(RegressionFunction2 rf, double[ ] start, double ftol)
public void simplexPlot(RegressionFunction3 rf, double[ ] start, double ftol)
Usage:                      reg.simplexPlot(rf, start, ftol);
Performs all that is described above under reg.simplex(rf, start, ftol) and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed y values versus the calculated y values. This plot can be suppressed (see suppressYYplot()).
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list). The output of this file can be suppressed (see suppressPrint())

public void simplexPlot(RegressionFunction rf, RegressionDerivativeFunction rdf, double[ ] start, double ftol)
public void simplexPlot(RegressionFunction2 rf, RegressionDerivativeFunction2 rdf, double[ ] start, double ftol)
public void simplexPlot(RegressionFunction3 rf, RegressionDerivativeFunction rdf, double[ ] start, double ftol)
public void simplexPlot(RegressionFunction3 rf, RegressionDerivativeFunction2 rdf, double[ ] start, double ftol)
Usage:                      reg.simplexPlot(rf, rfd, start, ftol);
Performs all that is described above under reg.simplex(rf, rfd, start, ftol) and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed y values versus the calculated y values. This plot can be suppressed (see suppressYYplot()).
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list). The output of this file can be suppressed (see suppressPrint())

public void simplex(RegressionFunction rf, double[ ] start, int nmax)
public void simplex(RegressionFunction2 rf, double[ ] start, int nmax)
public void simplex(RegressionFunction3 rf, double[ ] start, int nmax)
Usage:                      reg.simplex(rf, start, nmax);
As reg.simplex(rf, start, step, ftol, nmax) above with the exception that the initial simplex step sizes and the termination tolerance are not provided as arguments. Default values of 0.5 times the corresponing initial estimate [start] for all parameters and 1e-9 respectively are used.

public void simplex(RegressionFunction rf, RegressionDerivativeFunction rdf, double[ ] start, int nmax)
public void simplex(RegressionFunction2 rf, RegressionDerivativeFunction2 rdf, double[ ] start, int nmax)
public void simplex(RegressionFunction3 rf, RegressionDerivativeFunction rdf, double[ ] start, int nmax)
public void simplex(RegressionFunction3 rf, RegressionDerivativeFunction2 rdf, double[ ] start, int nmax)
Usage:                      reg.simplex(rf, rfd, start, nmax);
As reg.simplex(rf, rfd, start, step, ftol, nmax) above with the exception that the initial simplex step sizes and the termination tolerance are not provided as arguments. Default values of 0.5 times the corresponing initial estimate [start] for all parameters and 1e-9 respectively are used.

public void simplexPlot(RegressionFunction rf, double[ ] start, int nmax)
public void simplexPlot(RegressionFunction2 rf, double[ ] start, int nmax)
public void simplexPlot(RegressionFunction3 rf, double[ ] start, int nmax)
Usage:                      reg.simplexPlot(rf, start, nmax);
Performs all that is described above under reg.simplex(rf, start, nmax) and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed y values versus the calculated y values. This plot can be suppressed (see suppressYYplot()).
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list). The output of this file can be suppressed (see suppressPrint()).

public void simplexPlot(RegressionFunction rf, RegressionDerivativeFunction rdf, double[ ] start, int nmax)
public void simplexPlot(RegressionFunction2 rf, RegressionDerivativeFunction2 rdf, double[ ] start, int nmax)
public void simplexPlot(RegressionFunction3 rf, RegressionDerivativeFunction rdf, double[ ] start, int nmax)
public void simplexPlot(RegressionFunction3 rf, RegressionDerivativeFunction2 rdf, double[ ] start, int nmax)
Usage:                      reg.simplexPlot(rf, rfd, start, nmax);
Performs all that is described above under reg.simplex(rf, rfd, start, nmax) and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed y values versus the calculated y values. This plot can be suppressed (see suppressYYplot()).
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list). The output of this file can be suppressed (see suppressPrint()).

public void simplex(RegressionFunction rf, double[ ] start)
public void simplex(RegressionFunction2 rf, double[ ] start)
public void simplex(RegressionFunction3 rf, double[ ] start)
Usage:                      reg.simplex(rf, start);
As reg.simplex(rf, start, step, ftol, nmax) above with the exception that the initial simplex step sizes, the termination tolerance and the maximum number of iterations are not provided as arguments. Default values of 0.5 times the corresponing initial estimate [start] for all parameters, 1e-9 and 3000 respectively are used.

public void simplex(RegressionFunction rf, RegressionDerivativeFunction rdf, double[ ] start)
public void simplex(RegressionFunction2 rf, RegressionDerivativeFunction2 rdf, double[ ] start)
public void simplex(RegressionFunction3 rf, RegressionDerivativeFunction rdf, double[ ] start)
public void simplex(RegressionFunction3 rf, RegressionDerivativeFunction2 rdf, double[ ] start)
Usage:                      reg.simplex(rf, rfd, start);
As reg.simplex(rf, rfd, start, step, ftol, nmax) above with the exception that the initial simplex step sizes, the termination tolerance and the maximum number of iterations are not provided as arguments. Default values of 0.5 times the corresponing initial estimate [start] for all parameters, 1e-9 and 3000 respectively are used.

public void simplexPlot(RegressionFunction rf, double[ ] start)
public void simplexPlot(RegressionFunction2 rf, double[ ] start)
public void simplexPlot(RegressionFunction3 rf, double[ ] start)
Usage:                      reg.simplexPlot(rf, start);
Performs all that is described above under reg.simplex(rf, start) and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed y values versus the calculated y values. This plot can be suppressed (see suppressYYplot()).
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list). The output of this file can be suppressed (see suppressPrint()).

public void simplexPlot(RegressionFunction rf, RegressionDerivativeFunction rdf, double[ ] start)
public void simplexPlot(RegressionFunction2 rf, RegressionDerivativeFunction2 rdf, double[ ] start)
public void simplexPlot(RegressionFunction3 rf, RegressionDerivativeFunction rdf, double[ ] start)
public void simplexPlot(RegressionFunction3 rf, RegressionDerivativeFunction2 rdf, double[ ] start)
Usage:                      reg.simplexPlot(rf, rfd, start);
Performs all that is described above under reg.simplex(rf, rfd, start) and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed y values versus the calculated y values. This plot can be suppressed (see suppressYYplot()).
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list). The output of this file can be suppressed (see suppressPrint()).

DEPRECATED SIMPLEX METHODS
The simplex2, simplexPlot2 and plotXY2 methods are now deprecated. They have been retained in the flanagan.jar file but are no longer documented here. Their function has been incorporated in the above simplex, simplexPlot and PlotXY methods. To update a program to remove the deprecated methods replace a simplex2 method by the corresponding simplex method, a simplexPlot2 method by the corresponding simplexPlot method and a plotXY2 method by a correswponding plotXY method, i.e. simply remove the 2.

CODING THE FUNCTION TO WHICH THE DATA IS TO BE FITTED
The mathematical function, to which the data is to be fitted, may be coded in a function that overrides the function in one of the following intertfaces:
• RegressionFunction
This interace contains a single function
public double function(double[ ] p, double[ ] x)
The mathematical function, to which the data is to be fitted, should be coded in a function of the the same signiture in a class which implements RegressionFunction, an instance of which should be created in the method calling a simplex or simplexPlot method.
This interface is typically used in fitting data in which there is a one-dimension array of dependent values (y) and no errors associated with the values of the dependent variable/s, (x). In this case the argument p[] is used to pass the current estimates of parameters, whose best estimates are required, from the simplex minimisation method to this function, x[] is used to pass the dependent variable values, at the point whose calculated value is required, to this function. The body of the function should contain the coding of the mathematical function to be fitted such that a calculated value of the dependent variable, yi, for the data point of interest is obtained. This value should then be returned from the function. Examples of this procedure may be found in the Example Programs.

• RegressionFunction2
This interace contains a single function
public double function(double[ ] p, double[ ] x, int i)
The mathematical function, to which the data is to be fitted, should be coded in a function of the the same signiture in a class which implements RegressionFunction2, an instance of which should be created in the method calling a simplex or simplexPlot method.
This interface is typically used in fitting data in which there is a two-dimension array of dependent values (y) and no errors associated with the values of the dependent variable/s, (x). In this case the argument p[] is used to pass the current estimates of parameters, whose best estimates are required, from the simplex minimisation method to this function, x[] is used to pass the dependent variable values, at the point whose calculated value is required, to this function and i is used to pass the index of the data point for which the calculation is being made. The body of the function should contain the coding of the mathematical function to be fitted such that a calculated value of the dependent variable, yi, for the data point of interest is obtained. This value should then be returned from the function.
Dependent variable data (y) entered as a multidimensional array is automaticaly rearranged as consecutive blocs in a one dimensional array. The argument i refers to this one dimensional array allowing the identification of the original point.
Examples of this procedure may be found in the Example Programs.

• RegressionFunction3
This interace contains a single function
public double[] function(double[ ] p, double[ ] x, int i)
The mathematical function, to which the data is to be fitted, should be coded in a function of the the same signiture in a class which implements RegressionFunction3, an instance of which should be created in the method calling a simplex or simplexPlot method.
This interface is typically used in fitting data in which there is either a one- or two-dimension array of dependent values (y) and in which there are errors associated with the values of the dependent variable/s, (x). In this case the argument p[] is used to pass the current estimates of parameters, whose best estimates are required, from the simplex minimisation method to this function, x[] is used to pass the dependent variable values, at the point whose calculated value is required, to this function and i is used to pass the index of the data point for which the calculation is being made. The body of the function should contain the coding of the mathematical function to be fitted such that a calculated value of the dependent variable, yi, for the data point of interest is obtained as is a value of the weighting factor calculated as described above. These value should then be returned from the function as a array of doubles of length 2, e.g. ret[2], in which the calculated y value is returned in the first element, e.g. ret[0] and the square of the calculated weight, i.e. the total estimated variance of yi, is returned in the second element, e.g. ret[1].
Dependent variable data (y) entered as a multidimensional array is automaticaly rearranged as consecutive blocs in a one dimensional array. The argument i refers to this one dimensional array allowing the identification of the original point.
Examples of this procedure may be found in the Example Programs [RegressionExampleSix.java].

Any constants in the mathematical function, to which the data that is to be fitted, that are not included in the set of parameters for which we require an estimate, i.e. constants of known fixed value, are not transferred to the function via the argument list but should be declared as members of the class, implementing the RegressionFunctionn, of which function(...) is a member. Their values may be set in that declaration and can be reset within the calling program (see Example Program below).

Compatibility Table for RegressionFunction and RegressionDerivativeFunction Interfaces

 RegressionDerivativeFunction RegressionDerivativeFunction2 RegressionFunction YES NO RegressionFunction2 NO YES RegressionFunction3 YES YES

CODING OF THE HESSIAN SECOND DERIVATIVES
The estimates of the variances of the best estimates obtained by non-linear regression are calculated by assuming that the sum of squares surface approximates to one of a linear model close to the minimum. Such a calculation involves obtaining the variance-covariance matrix by inverting the Hessian matrix of second derivatives of the weighted sum of squares at the minimum with respect to all pairs of estimated parameters. These differentials may be either obtained
numerically. or calculated analytically. If they are calculated analytically the three derivatives

where f(p,x) is the fitted function, pi and pj are the best estimates of a pair of parameters of indices i and j,
must be coded in a function that overrides the function in one of the following interfaces:
• RegressionDerivativeFunction
This interace contains a single function
public double[] function(double[ ] p, double[ ] x, int i, int j)
The derivatives should be coded in a function of the the same signiture in a class which implements RegressionDerivativeFunction, an instance of which should be created in the method calling a simplex or simplexPlot method.
This interface is typically used in fitting data in which there is a one dimension array of dependent values (y). In this case the argument p[] is used to pass the current estimates of parameters, whose best estimates are required, from the simplex minimisation method to this function, x[] is used to pass the dependent variable values, at the point whose calculated value is required, to this function and i and j are used to pass the indices, i and j, of the parameters with respect to which the function is to differentiated ands and k is used to pass the index of the data point for which the calculation is being made. The body of the function should contain the coding of the three derivatives. These values should then be returned from the function in an array of doubles of length 3, e.g. ret[3] and the three elements, e.g. ret[0], ret[1] and ret[2], should contain the values of the derivatives

in that order.

• RegressionDerivativeFunction2
• This interace contains a single function
public double[] function(double[ ] p, double[ ] x, int i, int j, int k)
The derivatives should be coded in a function of the the same signiture in a class which implements RegressionDerivativeFunction2, an instance of which should be created in the method calling a simplex or simplexPlot method.
This interface is typically used in fitting data in which there is a two dimension array of dependent values (y). In this case the argument p[] is used to pass the current estimates of parameters, whose best estimates are required, from the simplex minimisation method to this function, x[] is used to pass the dependent variable values, at the point whose calculated value is required, to this function and i and j are used to pass the indices, i and j, of the parameters with respect to which the function is to differentiated . The body of the function should contain the coding of the three derivatives. These values should then be returned from the function in an array of doubles of length 3, e.g. ret[3] and the three elements, e.g. ret[0], ret[1] and ret[2], should contain the values of the derivatives

in that order.
Dependent variable data (y) entered as a multidimensional array is automaticaly rearranged as consecutive blocs in a one dimensional array. The argument k refers to this one dimensional array allowing the identification of the original point.

The Regression class statistical method uses the returned derivatives to calculate the value of the second derivative of the weighted sum of squares

where yk is the value of the dependent variable and n is the number of dependent variable data points. If no weights have been provided the unweighted sum of squares is used and an estimate of the variance of the dependent variables is used in calculating the variance-covariance matrix.

Any constants in the function, to which the data that is to be fitted, that are not included in the set of parameters for which we require an estimate, i.e. constants of known fixed value, are not transferred to the function via the argument list but should be declared as members of the class of which function(x) is a member. Their values may be set in that declaration and can be reset within the calling program (see Example Program below).

Compatibility Table for RegressionFunction and RegressionDerivativeFunction Interfaces

 RegressionDerivativeFunction RegressionDerivativeFunction2 RegressionFunction YES NO RegressionFunction2 NO YES RegressionFunction3 YES YES

CONSTRAINED NON-LINEAR REGRESSION
Add a constraint applied to individual parameters
public void addConstraint(int pIndex, int direction, double boundary)
Usage:                      reg.addConstraint(pIndex, direction, boundary);
This method allows the addition of a simple, but often effective constraint, to the non-linear regression. A parameter may be constrained either to take only values above a certain value or below a certain value. The arguments of the method, [in the above usage], are:
• pIndex: the index of the parameter to be constrained [remember, indices start at 0, i.e. the first parameter to be estimated as an index 0]
• direction:
• direction set to −1: the constraint applies below the constraint boundary, i.e. the parameter may only take values above the constraint boundary
• direction set to +1: the constraint applies above the constraint boundary, i.e. the parameter may only take values below the constraint boundary
• direction set to   0: The parameter will be constrained to a single constraint value (boundary) within a tolerance of 0.01% of the constraint value, i.e. a parameter with a supplied boundary value of 2.1 will be constrained to the interval 2.1*(1 − 10−4) to 2.1*(1 + 10−4). Whether the regression can achieve this will depend on the tolerance, 10−4, exceeding the rounding error. This tolerance may be reset using the setConstraintTolerance method. This is not a sensible way to fix a value. It would be more sensible to rewrite the regression function with this parameter set at a fixed value, e.g. 2.1 in this example. The value of this option is in constraining a sum of parameters (see immediately below).
• boundary: the boundary value, i.e. the value of the current estimate of the parameter beyond which the constraint applies.
More than one constraint may be added and more than one constraint may be applied to the same parameter
If an attempt to enter a constrained region is made the chi square [weighted data] or sum of squares [unweighted data] is not calculated but is replaced by the previously calculated value plus a penalty term equal to a penalty weight [see setPenaltyWeight below] multiplied by the square of the attempted estimate of the parameter entering the constraint region minus the constraint boundary value, i.e. if any set constraint is violated

is replaced by

where there are q parameters constrained to lay above lower boundaries, li, r parameters constrained to lay below upper boundaries, ui and s parameters constrained to fixed values, fi within a tolerance, t, H(arg) is the Heaviside step function taking the value of zero for arg < or = 0 and a value of 1 for arg >0, Pw is the penalty weight and χ2previous value is the last calculated value of χ2 in which no constraint boundaries were violated. If the sum of squares is being minimised, i.e. an unweighted regression, an analogous repacement is made. This is an ad hoc method of constraining the regression and if a best estimate is returned at a constraint barrier the associated statistics, already questionable if the χ2 surface around the minimum does not approximate to a quadratic surface characteristic of a linear regression, will be invalidated.

Add a constraint applied to a summation of some or all parameters
public void addConstraint(int[] pIndices, double[] plusOrMinus, int direction, double boundary)
public void addConstraint(int[] pIndices, int[] plusOrMinus, int direction, double boundary)
Usage:                      reg.addConstraint(pIndices, plusOrMinus, direction, boundary);
This method allows the addition of a simple, but often effective constraint, to the non-linear regression. A sum of some or all of the parameters may be constrained either to take only values above a certain value or below a certain value. The arguments of the method, [in the above usage], are:
• pIndices: the indices of the parameter to be included in the constraint [remember, indices start at 0, i.e. the first parameter to be estimated as an index 0]
• plusOrMinus: the values by which the individual parameters in the sum should be multiplied.
• direction:
• direction set to −1: the constraint applies below the constraint boundary, i.e. the parameter may only take values above the constraint boundary
• direction set to +1: the constraint applies above the constraint boundary, i.e. the parameter may only take values below the constraint boundary
• direction set to   0: The designated sum of parameters will be constrained to a single constraint value (boundary) within a tolerance of 0.01% of the constraint value, i.e. if three parameters aa, bb and dd are to be constrained as aa + bbdd = 2.1 the regression will attempt to constrain aa + bbdd to the interval 2.1*(1 − 10−4) to 2.1*(1 + 10−4). Whether the regression can achieve this will depend on the tolerance, 10−4, exceeding the rounding error. This tolerance may be reset using the setConstraintTolerance method.
• boundary: the boundary value, i.e. the value of the current estimate of the parameter beyond which the constraint applies.
For example, if, for a non-linear regression with four parameters aa, bb, cc and dd, whose initial estimates were set in start[0], start[1], start[2] and start[3] respectively, one wishes to apply the constraint,
1.1aa − 2.3bb + 5.7dd > 13.4,
the addConstraint method would be called with:
pIndices[0] = 0, pIndices[1] = 1, pIndices[2] = 3;
plusOrMinus[0] = 1.1, plusOrMinus[1] = −2.3, plusOrMinus[2] = 5.7;
direction = −1;
boundary = 13.4;

More than one constraint sum may be added.
If an attempt to enter a constrained region is made the value of the chi square [weighted data] or sum of squares [unweighted data] is not calculated but is replaced by the previously calculated value plus a penalty term equal to a penalty weight [see setPenaltyWeight below] multiplied by the square of the attempted estimate of the constraint sum minus the constraint boundary value, i.e. if any set constraint is violated

is replaced by

where there are q parameters constrained to lay above lower boundaries, li, r parameters constrained to lay below upper boundaries, ui and s parameters constrained to fixed values, fi within a tolerance, t, H(arg) is the Heaviside step function taking the value of zero for arg < or = 0 and a value of 1 for arg >0, Pw is the penalty weight and χ2previous value is the last calculated value of χ2 in which no constraint boundaries were violated. If the sum of squares is being minimised, i.e. an unweighted regression, an analogous repacement is made. This is an ad hoc method of constraining the regression and if a best estimate is returned at a constraint barrier the associated statistics, already questionable if the χ2 surface around the minimum does not approximate to a quadratic surface characteristic of a linear regression, will be invalidated.

Remove all constraints
public void removeConstraints()
Usage:                      reg.removeConstraints();
If a new regression method is called, any previously added constraints will remain active and be applied to the new parameters unless removed. This method removes all constraints.

Reset the penalty weight
public void setPenaltyWeight(double pWeight)
Usage:                      reg.setPenaltyWeight(pWeight);
This method resets the penalty weight [pWeight in the above usage] used by the constraint procedure [see addConstraint immediately above]. The default value is 1e30.

Return the penalty weight
public double getPenaltyWeight()
Usage:                      pWeight = reg.getPenaltyWeight();
Returns the penalty weight used by the constraint procedure [see addConstraint immediately above]. The default value is 1e30.

Reset the constraint tolerance
public void setConstraintTolerance(double tolerance)
Usage:                      reg.setConstraintTolerance(tolerance);
Resets the tolerance value used by the constraint procedure for multiple parameters and a fixed constraint value [see addConstraint immediately above]. The default value is 10−4.

SCALING OF THE INITIAL ESTIMATES
Reset the scaling factors applied to the initial estimates
public void setScale(int opt)
public void setScale(double[] opt)
Usage:                      reg.setScale(opt);
Resets the factors by which the initial estimates unknown parameters are scaled. The options [opt in the above usage] may take values:
• opt = an int of value = 0: No scaling occurs
• opt = an int of value = 1; All estimates are scaled to unity
• opt = a double[ ] (one dimensional array of length equal to the number of initial estimates): The estimates are scaled to values in the array opt
The default value is opt=0, i.e. no scaling. Scaling is advised if there are significant disparities between some of the magnitudes of the initial estimates. If the default option is to be overriden, setScale must be called before the non-linear regression method is called.

Get the scaling factors
public double[ ] getScale()
Usage:                      scale = reg.getScale();
Returns the scaling factors applied to the initial estimates used by the Nelder and Mead Simplex method.

RETURNING THE INITIAL ESTIMATES
Returning the unscaled initial estimates
public double[] getInitialEstimates()
Usage:                      starts = reg.getInitialEstimates();
This method returns the initial estimates used by the Nelder and Mead simplex regression methods as either entered by the user or calculated internally. The values returned are those before any scaling has occurred. See below for a method returning the scaled values.

Returning the scaled initial estimates
public double[] getScaledInitialEstimates()
Usage:                      starts = reg.getScaledInitialEstimates();
This method returns the scaled initial estimates used by the Nelder and Mead simplex regression methods as either entered by the user or calculated internally. The values returned are those after any scaling has occurred. if no scaling has occurred these values will be identical to those reurned by getInitialEstimates(). See above for a method returning the unscaled values.

RETURNING THE INITIAL STEP SIZES
Returning the unscaled initial step sizes
public double[] getInitialSteps()
Usage:                      starts = reg.getInitialSteps();
This method returns the initial step sizes used by the Nelder and Mead simplex regression methods as either entered by the user or calculated internally. The values returned are those before any scaling has occurred. See below for a method returning the scaled values.

Returning the scaled initial step sizes
public double[] getScaledInitialSteps()
Usage:                      starts = reg.getScaledInitialSteps();
This method returns the scaled initial step sizes used by the Nelder and Mead simplex regression methods as either entered by the user or calculated internally. The values returned are those after any scaling has occurred. if no scaling has occurred these values will be identical to those reurned by getInitialSteps(). See above for a method returning the unscaled values.

CONVERGENCE TESTS
Reset the convergence test
public void setMinTest(int opt) Usage:                      reg.setMinTest(opt);
Resets the procedure by which the Simplex iteration is tested for convergence onto a minimum. The options [opt in the above usage] may take values:
• opt = 0: terminate if the standard deviation of the sum of squares [unweighted data] or of the chi square values [weighted data] at the apices of the simplex is less than the tolerance, ftol[see Nelder and Mead Simplex method for ftol].
• opt = 1; terminate if the reduced chi square [weighted data] or the reduced sum of squares [unweighted data] at the lowest apex of the simplex is less than the mean of the absolute values of the dependent variable (y values) multiplied by the tolerance, ftol.
The default value is opt=0.

Get the convergence test option
public int getMinTest()
Usage:                      scale = reg.getMinTest();
Returns the convergence test option. See immediately above for details of this option.

Reset the tolerance value
public void setTolerance(double fTol)
Usage:                      reg.=setTolerance(fTol);
Resets the tolerance [fTol in the above usages] used in testing for convergence. See setMinTest above for details.

Get the tolerance value
public int getTolerance()
Usage:                      fTol = reg.getTolerance();
Returns the tolerance [fTol in the above usages] used in testing for convergence. See setMinTest above for details.

Get the simplex standard deviation
public double getSimplexSd()
Usage:                      simplexSd = reg.getSimplexSd();
Returns the standard deviation of the simplex at the minimum. See setMinTest above for details of its use in testing for convergence.

RESTARTS
Reset the maximum number of restarts
public void setNrestartsMax(int nrm)
Usage:                      reg.setNrestartsMax(nrm);
Resets the maximum number of restarts allowed in the Nelder and Mead Simplex procedure. On reaching a minimum the procedure will be restarted this number [nrm in the above usage] of times. The default option is 3.

Get the maximum number of restarts allowed
public int getNrestartMax()
Usage:                      nrm = reg.getNrestartsMax();
Returns the maximum number of restarts allowed.

Get the number of restarts that occured
public int getNrestart()
Usage:                      nr = reg.getNrestarts();
Returns the number of restarts that occured.

NUMBER OF ITERATIONS
Reset the maximum number of iterations allowed
public void setNmax(double nMax)
Usage:                      reg.setNmax(nMax);
Resets the maximum number of iterations allowed in the Nelder and Mead simplex procedure to the method argument [nMax in the above usage]. The default value is 3000.

Get the maximum number of iterations allowed
public int getNmax()
Usage:                      nimax = reg.getNmax();
Returns the maximum number of iterations allowed in the Nelder and Mead simplex procedure.

Reset the minimum number of iterations required
public void setNmin(double nMin)
Usage:                      reg.setNmin(nMin);
Resets the minimum number of iterations required in the Nelder and Mead simplex procedure to the method argument [nMin in the above usage]. The default value is 300.

Get the minimum number of iterations required
public int getNmin()
Usage:                      nimin = reg.getNmin();
Returns the minimum number of iterations required in the Nelder and Mead simplex procedure.

Get the number of iterations taken
public int getNiter()
Usage:                      nr = reg.getNiter();
Returns the number of iterations taken.

Gradients about the minimum
public double[ ][ ] getGrad()
Usage:                      grad = reg.getGrad();
Returns the gradients, calculated as difference equations, immediately before

and immediatley after

the minimum, for all paramters. The pre-minimum gradients are returnen in, in the above usage, in grad[0][0], grad[0][1], grad[0][2]... and the post-minimum gradients are returned in grad[1][0], grad[1][1], grad[1][2].... These gradients are only calculated in the case of a non-linear regression and a null value is returned if the regression is linear.

THE NELDER AND MEAD SIMPLEX COEFFICIENTS
Reset the reflection coefficient
public void setNMreflect(doublereflectC)
Usage:                      reg.setNMreflect(reflectC);
Resets the Nelder and Mead simplex reflection coefficient. The default value is 1.0D.

Get the reflection coefficient
public double getNMreflect()
Usage:                      reflectC = reg.getNMreflect();
Returns the Nelder and Mead simplex reflection coefficient. The default value is 1.0D.

Reset the extension coefficient
public void setNMextend(doubleextendC)
Usage:                      reg.setNMextend(extendC);
Resets the Nelder and Mead simplex extension coefficient. The default value is 2.0D.

Get the reflection coefficient
public double getNMextend()
Usage:                      extedC = reg.getNMextend();
Returns the Nelder and Mead simplex extension coefficient. The default value is 2.0D.

Reset the contraction coefficient
public void setNMcontract(doublecontractC)
Usage:                      reg.setNMcontract(contractC);
Resets the Nelder and Mead simplex contraction coefficient. The default value is 0.5D.

Get the contraction coefficient
public double getNMcontract()
Usage:                      contractC = reg.getNMcontract();
Returns the Nelder and Mead simplex contraction coefficient. The default value is 0.5D.

### FITTING DATA TO SPECIAL FUNCTIONS

The Regression class's instance methods allowing data to be fitted to individual distributions, with access to all this class's regression methods, are listed below.

A static method (fitOneOrSeveralDistribtions(dataArray) below) allows a rapid scan of the fitting of the data in the double array, dataArray, to one, several or all of the distributions treated in this class, with limited output of the best fit details.

The Ordinate Axis Scaling Factor Option
All regressions in which data is fitted to any of the special functions may be performed with an ordinate axis scaling factor, Ao, either set equal to a fixed value, typically 1 or 100, or included as a parameter to be estimated. The default option is inclusion of Ao in the parameters to be estimated. The methods listed below allow this option to be changed.
Setting the Ordinate Axis Scaling Factor
public void setYscaleFactor(double scaleFacor)
Usage:                      reg.setYscaleFactor(scaleFactor);
This method will set the ordinate axis scaling factor, Ao, to a fixed value equal to the value of the argument, scaleFactor.

Setting the Ordinate Axis Scaling Factor Option
public void setYscaleOption(boolean test)
Usage:                      reg.setYscaleOption(test);
Setting test to false will set the ordinate axis scaling factor, Ao, to unity. See immediately setYscaleFactor() immediately below for fixing Ao to a value other than unity.
Setting test to true will ensure that the ordinate axis scaling factor, Ao, is included amongst the parameters to be estimated by the regression procedure.
The older method reg.setYscale(test) performs the same function as reg.setYscaleOption(test) and has been retained to ensure backward compatibility.

Getting the Ordinate Axis Scaling Factor Option
public boolean setYscale()
Usage:                      test = reg.getYscale();
Returns ordinate axis scaling factor, Ao, option.
If false is returned, the ordinate axis scaling factor, Ao, is equal to unity.
If true is returned, the ordinate axis scaling factor, Ao, is included amongst the parameters to be estimated by the regression procedure.
The older method reg.getYscale() performs the same function as reg.getYscaleOption() and has been retained to ensure backward compatibility.

Fit data to a Gaussian (Normal) Distribution Function
NB: The ProbabilityPlot class is likely to be more useful in fitting data to a Gaussian [Normal] distribution.

See below for a Gaussian fitting method with an option to fix one or more of the parameters.
public void gaussian()
Usage:                      reg.gaussian();
Fits the data to the Gaussian (normal) distribution function, p(x), where

and μ and σ are the mean and standard deviation of the normal (Gaussian) distribution and Ao is a scaling factor. The parameters μ, σ and Ao are the parameters to be estimated. A Nelder and Mead Simplex procedure is used. See Ordinate Scaling Factor Option (above) for the procedure by which the ordinate scaling factor, Ao, may be set to a fixed value, typically 1 or 100. See Constructors and the class Stat for details of Gaussian statistical methods and for fitting a data set that has first to be binned into a set of observation frequency bins.

Fit data to a Gaussian (Normal) Distribution Function and plot results
public void gaussianPlot()
Usage:                      reg.gaussianPlot();
Performs all that is described above under reg.gaussian(parameterValues, fixedOptions) and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed p(x) values versus the calculated p(x) values
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list).
Fit data to a Gaussian (Normal) Distribution Function with an option to fix parameters
See above for a Gaussian fitting method with no option to fix the parameters.
public void gaussian(double[] parameterValues, boolean[] fixedOptions)
Usage:                      reg.gaussian(parameterValues, fixedOptions);
Fits the data to the Gaussian (normal) distribution function, p(x), where

and μ and σ are the mean and standard deviation of the normal (Gaussian) distribution and Ao is a scaling factor. The parameters μ, σ and Ao are the parameters to be estimated or fixed. The argument parameterValues must contain the initial estimate or fixed value of the mean, μ, standard deviation, σ, and the scale factor, Ao, in that order. The argument fixedOptions must contain three booleans, each corresponding to the three parameters, μ, σ and Ao, in that order. The boolean should be true if the parameter is to be fixed at the given value in the parameterValues list. It should be false if the parameter is not to be fixed, i.e. the best estimate is to be found by the regression procedure. In the latter case the value in the parameterValues list will be taken as the initial estimate for the regression procedure. A Nelder and Mead Simplex procedure is used. See Constructors and the class Stat for details of Gaussian statistical methods and for fitting a data set that has first to be binned into a set of observation frequency bins.

Fit data to a Gaussian (Normal) Distribution Function and plot results
public void gaussianFixedPlot(double[] parameterValues, boolean[] fixedOptions)
Usage:                      reg.gaussianPlot(parameterValues, fixedOption);
Performs all that is described above under reg.gaussian(parameterValues, fixedOption) and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed p(x) values versus the calculated p(x) values
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list).

Fit data to a multiple Gaussian (Normal) Distribution Functions and plot results
public void multipleGaussiansPlot(int nGaussians, double[] guessesOfMeans, double[] guessesOfStandardDeviations, double[] guessesOfFractionalContributions)
Usage:                      reg.multipleGaussiansPlot(nGaussians, guessesOfMeans, guessesOfStandardDeviations, guessesOfFractionalContributions);
Fits the data to the sum of n [nGaussians] Gaussian (normal) distribution functions, p(x), where

and μi and σi are the means and standard deviations of the normal (Gaussian) distributions, Ai are the scaling factors for each distribution, B is an overall scaling factor and fi are the fractional contribution of each distribution. The parameters μ, σ and Ai are the parameters estimated. The reported values for the parameters B and fi are derived from the estimated values of Ai.
This method of fitting to multiple Gaussians requires good initial estimates of the parameters whose values are required. These must be entered as the informed guesses [guessesOfMeans] of the values of the means, μi, of the individual Gaussian distributions, informed guesses [guessesOfStandardDeviations] of their standard deviations, σi, and informed guesses [guessesOfFractionalContributions] of the fractional contribution of each distribution, fi. The sum of the fractional contributions, fi, must equal 1.0.
A Nelder and Mead Simplex procedure is used.
This method also
• displays a plot of the data and best fit line
• displays a plot of the observed p(x) values versus the calculated p(x) values
• outputs a text file of best estimates of the both the estimated coefficients and the derived coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list).
See Constructors and the class Stat for details of Gaussian statistical methods and for fitting a data set that has first to be binned into a set of observation frequency bins.

Static method
The static method (fitOneOrSeveralDistribtions(dataArray)) allows the fitting of the data in the double array, dataArray, to a Gaussian (normal) distribution [with no fixed parameter option], and to other distributions, but with limited output of the best fit details. See below for details.

Unbinned data
In addition to the above methods used in combination with the appropriate Constructors or Stat binning methods for unbinned data see also the ProbabilityPlot class methods under Gaussian Probability Plots. These methods return best fit estimates of μ and σ.

Fit data to a Log-normal Distribution Function
Both the two parameterlog-normal and the three parameter log-normal distributions are included in this class.

Fit data to a Two Parameter Log-Normal Distribution
public void logNormal()
public void logNormalTwoPar()
Usage:                      reg.logNormal();
Fits the data to the Two Parameter Log-normal distribution function, p(x), where

and μ and σ are the location and shape parameters of the two parameter log-normal distribution and Ao is a scaling factor. The parameters μ, σ and Ao are the parameters to be estimated. A Nelder and Mead Simplex procedure is used. See Ordinate Scaling Factor Option (above) for the procedure by which the ordinate scaling factor, Ao, may be set to a fixed value, typically 1 or 100. See Constructors and the class Stat for details of the two parameter log-normal distribution statistical methods and for fitting a data set that has first to be binned into a set of observation frequency bins.

The method, logNormalTwoPar, is identical to the above method, logNormal.

Fit data to a Two Parameter Log-Normal Distribution Function and plot results
public void logNormalPlot()
public void logNormalTwoParPlot()
Usage:                      reg.logNormalPlot();
Performs all that is described above under reg.logNormal() and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed p(x) values versus the calculated p(x) values
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list).
The method, logNormalTwoParPlot, is identical to the above method, logNormalPlot.

Static method
The static method (fitOneOrSeveralDistribtions(dataArray)) allows the fitting of the data in the double array, dataArray, to a Logistic distribution, and to other distributions, but with limited output of the best fit details. See below for details.

Fit data to a Three Parameter Log-normal Distribution Function
public void logNormalThreePar()
Usage:                      reg.logNormalThreePar();
Fits the data to the Three Parameter Log-normal distribution function, p(x), where

and α, β and γ are the location, shape and scale parameters of the three parameter log-normal distribution and Ao is a scaling factor. The parameters α, β, γ and Ao are the parameters to be estimated. A Nelder and Mead Simplex procedure is used. See Ordinate Scaling Factor Option (above) for the procedure by which the ordinate scaling factor, Ao, may be set to a fixed value, typically 1 or 100. See Constructors and the class Stat for details of the two parameter log-normal distribution statistical methods and for fitting a data set that has first to be binned into a set of observation frequency bins.

Fit data to a Three Parameter Log-Normal Distribution Function and plot results
public void logNormalThreeParPlot()
Usage:                      reg.logNormalThreeParPlot();
Performs all that is described above under reg.logNormalThreePar() and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed p(x) values versus the calculated p(x) values
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list).
Static method
The static method (fitOneOrSeveralDistribtions(dataArray)) allows the fitting of the data in the double array, dataArray, to a Logistic distribution, and to other distributions, but with limited output of the best fit details. See below for details.

Fit data to a Logistic Distribution Function
See also Five Parameter Logistic and Four Parameter Logistic curves.
public void logistic()
Usage:                      reg.logistic();
Fits the data to the Logistic distribution function, p(x), where

and μ and β are the location and scale parameters of the Logistic distribution and Ao is a scaling factor. The parameters μ, β and Ao are the parameters to be estimated. A Nelder and Mead Simplex procedure is used. See Ordinate Scaling Factor Option (above) for the procedure by which the ordinate scaling factor, Ao, may be set to a fixed value, typically 1 or 100. See Constructors and the class Stat for details of Logistic distribution statistical methods and for fitting a data set that has first to be binned into a set of observation frequency bins.

Fit data to a Logistic Distribution Function and plot results
public void logisticPlot()
Usage:                      reg.logisticPlot();
Performs all that is described above under reg.logistic() and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed p(x) values versus the calculated p(x) values
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list).
Static method
The static method (fitOneOrSeveralDistribtions(dataArray)) allows the fitting of the data in the double array, dataArray, to a Logistic distribution, and to other distributions, but with limited output of the best fit details. See below for details.

Unbinned data
In addition to the above methods used in combination with the appropriate Constructors or Stat binning methods for unbinned data see also the ProbabilityPlot class methods under Logistic Probability Plots. These methods return best fit estimates of μ and β.

Fit data to a Beta Distribution Function
Fit data to a Beta Distribution on the interval [0,1]
public void beta()
Usage:                      reg.beta();
Fits the data to the Beta distribution on the interval [0,1],  p(x;α,β), where

and α and β are the shape parameters of the Beta distribution, B(α, β) is the Beta Function and Ao is a scaling factor. The parameters α, β and Ao are the parameters to be estimated. A Nelder and Mead Simplex procedure is used. See Ordinate Scaling Factor Option (above) for the procedure by which the ordinate scaling factor, Ao, may be set to a fixed value, typically 1 or 100. See Constructors and the class Stat for details of Beta distribution statistical methods and for fitting a data set that has first to be binned into a set of observation frequency bins.

Fit data to a Beta Distribution on the interval [0,1] and plot results
public void betaPlot()
Usage:                      reg.betaPlot();
Performs all that is described above under reg.beta() and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed p(x) values versus the calculated p(x) values
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list).
Fit data to a Beta Distribution on the interval [min,max]
public void betaMinMax()
Usage:                      reg.betaMinMax();
Fits the data to the Beta distribution on the interval [min, max],  p(x;α,β, min,max), where

and α and β are the shape parameters of the Beta distribution, B(α, β) is the Beta Function, min and max are the minimum and maximum values respectively that x may take and Ao is a scaling factor. The parameters α, β, min, max and Ao are the parameters to be estimated. A Nelder and Mead Simplex procedure is used. See Ordinate Scaling Factor Option (above) for the procedure by which the ordinate scaling factor, Ao, may be set to a fixed value, typically 1 or 100. See Constructors and the class Stat for details of Beta distribution statistical methods and for fitting a data set that has first to be binned into a set of observation frequency bins.

Fit data to a Beta Distribution on the interval [min,max] and plot results
public void betaMinMaxPlot()
Usage:                      reg.betaMinMaxPlot();
Performs all that is described above under reg.betaMinMax() and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed p(x) values versus the calculated p(x) values
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list).
Static method
The static method (fitOneOrSeveralDistribtions(dataArray)) allows the fitting of the data in the double array, dataArray, to a Beta distribution on the interval [min,max], and to other distributions, but with limited output of the best fit details. See below for details.

Fit data to a Gamma Distribution Function
Fit data to a Three Parameter Gamma Distribution
public void gamma()
Usage:                      reg.gamma();
Fits the data to the Three Parameter Gamma distribution,  p(x;β,γ,μ), where

and μ is the location parameter, β is the scale parameter, γ is the shape parameter, Γ(α), the Gamma Function and Ao is a scaling factor. The parameters α, β and Ao are the parameters to be estimated. A Nelder and Mead Simplex procedure is used. See Ordinate Scaling Factor Option (above) for the procedure by which the ordinate scaling factor, Ao, may be set to a fixed value, typically 1 or 100. See Constructors and the class Stat for details of Gamma distribution statistical methods and for fitting a data set that has first to be binned into a set of observation frequency bins.

Fit data to a Three Parameter Gamma Distribution and plot results
public void gammaPlot()
Usage:                      reg.gammaPlot();
Performs all that is described above under reg.gamma() and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed p(x) values versus the calculated p(x) values
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list).
Fit data to a Standard Gamma Distribution
public void gammaStandard()
Usage:                      reg.gammaStandard();
Fits the data to the Standard Gamma distribution,  p(x; γ), where

and γ is the shape parameter, Γ(α), the Gamma Function and Ao is a scaling factor. The parameters α, β and Ao are the parameters to be estimated. A Nelder and Mead Simplex procedure is used. See Ordinate Scaling Factor Option (above) for the procedure by which the ordinate scaling factor, Ao, may be set to a fixed value, typically 1 or 100. See Constructors and the class Stat for details of Gamma distribution statistical methods and for fitting a data set that has first to be binned into a set of observation frequency bins.

Fit data to a Standard Gamma Distribution and plot results
public void gammaStandardPlot()
Usage:                      reg.gammaStandardPlot();
Performs all that is described above under reg.gammaStandard() and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed p(x) values versus the calculated p(x) values
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list).
Static method
The static method (fitOneOrSeveralDistribtions(dataArray)) allows the fitting of the data in the double array, dataArray, to a Three Parameter Gamma distribution on the interval [min,max], and to other distributions, but with limited output of the best fit details. See below for details.

Fit data to an Erlang Distribution Function
public void erlang()
Usage:                      reg.erlang();
Fits the data to the Erlang distribution,  p(x;λ,k), where

and λ [argument double lambda] is the shape parameter, k [argument int kay] is the integer rate parameter and Ao is a scaling factor. The parameters λ, k and Ao are the parameters to be estimated. A Nelder and Mead Simplex procedure is used. See Ordinate Scaling Factor Option (above) for the procedure by which the ordinate scaling factor, Ao, may be set to a fixed value, typically 1 or 100. The Erlang distribution is equivalent to a Gamma Distribution in which the Gamma location parameter, μ is set to zero, the Gamma scale parameter, β, is the inverse of the Erlang rate paramete, λ, and the Gamma shape parameter, γ, is restricted to integer values, i.e. the Erlang shape parameter, k. See Constructors and the class Stat for details of Erlang distribution statistical methods and for fitting a data set that has first to be binned into a set of observation frequency bins.

Fit data to an Erlang Distribution and plot results
public void erlangPlot()
Usage:                      reg.erlangPlot();
Performs all that is described above under reg.erlang() and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed p(x) values versus the calculated p(x) values
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list).
Static method
The static method (fitOneOrSeveralDistribtions(dataArray)) allows the fitting of the data in the double array, dataArray, to an Erlang distribution on the interval [min,max], and to other distributions, but with limited output of the best fit details. See below for details.

Fit data to a Lorentzian (Cauchy) Distribution Function
public void lorentzian()
Usage:                      reg.lorentzian();
Fits the data to the lorentzian distribution function, p(x), where

and μ and Γ are the mean and half-width (width at half the maximum heigth) of the lorentzian distribution and Ao is a scaling factor. The parameters μ, Γ and Ao are the parameters to be estimated. A Nelder and Mead Simplex procedure is used. See Ordinate Scaling Factor Option (above) for the procedure by which the ordinate scaling factor, Ao, may be set to a fixed value, typically 1 or 100. See Constructors and the class Stat for details of Lorentzian statistical methods and for fitting a data set that has first to be binned into a set of observation frequency bins.

Fit data to a Lorentzian Probability Function and plot results
public void lorentzianPlot()
Usage:                      reg.lorentzianPlot();
Performs all that is described above under reg.lorentzian() and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed p(x) values versus the calculated p(x) values
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list).
Static method
The static method (fitOneOrSeveralDistribtions(dataArray)) allows the fitting of the data in the double array, dataArray, to a Lorenztian distribution, and to other distributions, but with limited output of the best fit details. See below for details.

Fit data to a Poisson Distribution Function
public void poisson()
Usage:                      reg.poisson();
Fits the data to the Poisson distribution function, p(x), where

and μ is the mean of the Poisson distribution and Ao is a scaling factor. The parameters μ, and Ao are the parameters to be estimated. A Nelder and Mead Simplex procedure is used.
The abscissa values, i.e. the values of k, although provided as an array of doubles, must, mathematically, be integers.
See Ordinate Scaling Factor Option (above) for the procedure by which the ordinate scaling factor, Ao, may be set to a fixed value, typically 1 or 100. See Constructors and the class Stat for details of Lorentzian statistical methods and for fitting a data set that has first to be binned into a set of observation frequency bins.

Fit data to a Poisson Probability Function and plot results
public void lorentzianPlot()
Usage:                      reg.poissonPlot();
Performs all that is described above under reg.poisson() and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed p(x) values versus the calculated p(x) values
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list).

Fit data to a Gumbel Distribution (minimum order statistic) Function [Type 1 Extreme Value Distribution (minimum order statistic)]
Fit data to a Two Parameter Gumbel Distribution (minimum order statistic) Function
public void gumbelMin()
Usage:                      reg.gumbelMin();
Fits the data to the Gumbel distribution (minimum order statistic) function, p(x), where

and μ is the location parameter, σ is the scale parameter and Ao is an ordinate scaling factor. The parameters μ, σ, and Ao are the parameters to be estimated. A Nelder and Mead Simplex procedure is used. See Ordinate Scaling Factor Option (above) for the procedure by which the ordinate scaling factor, Ao, may be set to a fixed value, typically 1 or 100. See Constructors and the class Stat for details of Gumbel statistical methods and for fitting a data set that has first to be binned into a set of observation frequency bins.

Fit data to a Two Parameter Gumbel Distribution (minimum order statistic) and plot results
public void gumbelMinPlot()
Usage:                      reg.gumbelMinPlot();
Performs all that is described above under reg.gumbelMin() and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed p(x) values versus the calculated p(x) values
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list).

Fit data to a One Parameter Gumbel Distribution (minimum order statistic) Function
public void gumbelMinOnePar()
Usage:                      reg.gumbelMinOnePar();
Fits the data to a one parameter Gumbel distribution function (minimum order statistic), p(x), where

σ is the scale parameter and Ao is an ordinate scaling factor. The parameters σ, and Ao are the parameters to be estimated, i.e. the location parameter, μ has been set to zero. A Nelder and Mead Simplex procedure is used. See Ordinate Scaling Factor Option (above) for the procedure by which the ordinate scaling factor, Ao, may be set to a fixed value, typically 1 or 100. See Constructors and the class Stat for details of Gumbel statistical methods and for fitting a data set that has first to be binned into a set of observation frequency bins.

Fit data to a One parameter Gumbel Distribution (minimum order statistic) and plot results
public void gumbelMinOneParPlot()
Usage:                      reg.gumbelMinOneParPlot();
Performs all that is described above under reg.gumbelMinOnePar() and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed p(x) values versus the calculated p(x) values
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list).

Fit data to a Standard Gumbel Distribution (minimum order statistic) Function
public void gumbelMinStandard()
Usage:                      reg.gumbelMinStandard();
Fits the data to the Standard Gumbel distribution (minimum order statistic) function, p(x), where

and Ao is an ordinate scaling factor. Ao is the parameter to be estimated, i.e. the scale parameter σ and the location parameter, μ has been set to zero. A linear regression is performed on p(x) = Ao.z where z = exp(x)exp(-exp(x)). See Ordinate Scaling Factor Option (above) for the procedure by which the ordinate scaling factor, Ao, may be set to a fixed value, typically 1 or 100. See Constructors and the class Stat for details of Gumbel statistical methods and for fitting a data set that has first to be binned into a set of observation frequency bins.

Fit data to a Standard Gumbel Distribution (minimum order statistic) and plot results
public void gumbelMinStandardPlot()
Usage:                      reg.gumbelMinStandardPlot();
Performs all that is described above under reg.gumbelMinStandard() and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed p(x) values versus the calculated p(x) values
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list).
Static method
The static method (fitOneOrSeveralDistribtions(dataArray)) allows the fitting of the data in the double array, dataArray, to a Two Parameter Gumbel Distribution (minimum order statistic), and to other distributions, but with limited output of the best fit details. See below for details.

Unbinned data
In addition to the above methods used in combination with the appropriate Constructors or Stat binning methods for unbinned data see also the ProbabilityPlot class methods under Gumbel (minimum order statistic) Probability Plots. These methods return best fit estimates of μ and σ.

Fit data to a Gumbel Distribution (maximum order statistic) Function [Type 1 Extreme Value Distribution (maximum order statistic)]
Fit data to a Two Parameter Gumbel Distribution (maximum order statistic) Function
public void gumbelMax()
Usage:                      reg.gumbelMax();
Fits the data to the Gumbel Distribution (maximum order statistic) function, p(x), where

and μ is the location parameter, σ is the scale parameter and Ao is an ordinate scaling factor. The parameters μ, σ, and Ao are the parameters to be estimated. A Nelder and Mead Simplex procedure is used. See Ordinate Scaling Factor Option (above) for the procedure by which the ordinate scaling factor, Ao, may be set to a fixed value, typically 1 or 100. See Constructors and the class Stat for details of Gumbel statistical methods and for fitting a data set that has first to be binned into a set of observation frequency bins.

Fit data to a Two parameter Gumbel Distribution (maximum order statistic) and plot results
public void gumbelMaxPlot()
Usage:                      reg.gumbelMaxPlot();
Performs all that is described above under reg.gumbelMax() and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed p(x) values versus the calculated p(x) values
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list).

Fit data to a One Parameter Gumbel Distribution (maximum order statistic) Function
public void gumbelMaxOnePar()
Usage:                      reg.gumbelMaxOnePar();
Fits the data to a one parameter Gumbel distribution (maximum order statistic) function, p(x), where

σ is the scale parameter and Ao is an ordinate scaling factor. The parameters σ, and Ao are the parameters to be estimated, i.e. the location parameter, μ has been set to zero. A Nelder and Mead Simplex procedure is used. See Ordinate Scaling Factor Option (above) for the procedure by which the ordinate scaling factor, Ao, may be set to a fixed value, typically 1 or 100. See Constructors and the class Stat for details of Gumbel statistical methods and for fitting a data set that has first to be binned into a set of observation frequency bins.

Fit data to a One parameter Gumbel Distribution (maximum order statistic) and plot results
public void gumbelMaxOneParPlot()
Usage:                      reg.gumbelMaxOneParPlot();
Performs all that is described above under reg.gumbelMaxOnePar() and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed p(x) values versus the calculated p(x) values
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list).

Fit data to a Standard Gumbel Distribution (maximum order statistic) Function
public void gumbelStandard()
Usage:                      reg.gumbelMaxStandard();
Fits the data to the Stanmdard Gumbel distribution (maximum order statistic) function, p(x), where

and Ao is an ordinate scaling factor. Ao is the parameter to be estimated, i.e. the scale parameter σ and the location parameter, μ has been set to zero. A linear regression is performed on p(x) = Ao.z where z = exp(-x)exp(-exp(-x)). See Ordinate Scaling Factor Option (above) for the procedure by which the ordinate scaling factor, Ao, may be set to a fixed value, typically 1 or 100. See Constructors and the class Stat for details of Gumbel statistical methods and for fitting a data set that has first to be binned into a set of observation frequency bins.

Fit data to a Standard Gumbel Distribution (maximum order statistic) and plot results
public void gumbelMaxStandardPlot()
Usage:                      reg.gumbelMaxStandardPlot();
Performs all that is described above under reg.gumbelMaxStandard() and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed p(x) values versus the calculated p(x) values
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list).
Static method
The static method (fitOneOrSeveralDistribtions(dataArray)) allows the fitting of the data in the double array, dataArray, to a Two Parameter Gumbel Distribution (maximum order statistic), and to other distributions, but with limited output of the best fit details. See below for details.

Unbinned data
In addition to the above methods used in combination with the appropriate Constructors or Stat binning methods for unbinned data see also the ProbabilityPlot class methods under Gumbel (maximum order statistic) Probability Plots. These methods return best fit estimates of μ and σ.

Fit data to a Fréchet Distribution Function [Type 2 Extreme Value Distribution]
Fit data to a Three parameter Fréchet Distribution Function
public void frechet()
Usage:                      reg.frechet();
This method fits the data to the three parameter Fréchet distribution function;

where μ is the location parametera, σ is the scale parameter, γ is the shape parameter and Ao is an ordinate scaling factor. The parameters μ, σ, γ and Ao are the parameters to be estimated. A Nelder and Mead Simplex procedure is used. See Ordinate Scaling Factor Option (above) for the procedure by which the ordinate scaling factor, Ao, may be set to a fixed value, typically 1 or 100. See Constructors and the class Stat for details of Fréchet statistical methods and for fitting a data set that has first to be binned into a set of observation frequency bins.

Fit data to a three parameter Fréchet Distribution and plot results
public void frechetPlot()
Usage:                      reg.frechetPlot();
Performs all that is described above under reg.frechet() and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed p(x) values versus the calculated p(x) values
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list).

Fit data to a Two parameter Fréchet Distribution Function
public void frechetTwoPar()
Usage:                      reg.frechetTwoPar();
This method fits the data to the two parameter Fréchet distribution function;

σ is the scale parameter, γ is the shape parameter and Ao is an ordinate scaling factor. The parameters σ, γ and Ao are the parameters to be estimated, i.e. the location parameter, μ has been set to zero. A Nelder and Mead Simplex procedure is used. See Ordinate Scaling Factor Option (above) for the procedure by which the ordinate scaling factor, Ao, may be set to a fixed value, typically 1 or 100. See Constructors and the class Stat for details of Fréchet statistical methods and for fitting a data set that has first to be binned into a set of observation frequency bins.

Fit data to a two parameter Fréchet Distribution and plot results
public void frechetTwpParPlot()
Usage:                      reg.frechetTwoParPlot();
Performs all that is described above under reg.frechetTwoPar() and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed p(x) values versus the calculated p(x) values
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list).

Fit data to a Standard Fréchet Distribution Function
public void frechetStandard()
Usage:                      reg.frechetStandard();
This method fits the data to the standard Fréchet distribution function;

γ is the shape parameter and Ao is an ordinate scaling factor. The parameters γ and Ao are the parameters to be estimated, i.e. the location parameter, μ has been set to zero and the scale parameter, σ has been set to unity. A Nelder and Mead Simplex procedure is used. See Ordinate Scaling Factor Option (above) for the procedure by which the ordinate scaling factor, Ao, may be set to a fixed value, typically 1 or 100. See Constructors and the class Stat for details of Fréchet statistical methods and for fitting a data set that has first to be binned into a set of observation frequency bins.

Fit data to a Standard Fréchet Distribution and plot results
public void frechetStandardPlot()
Usage:                      reg.frechetStandardPlot();
Performs all that is described above under reg.frechetStandard() and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed p(x) values versus the calculated p(x) values
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list).
Static method
The static method (fitOneOrSeveralDistribtions(dataArray)) allows the fitting of the data in the double array, dataArray, to a Three Parameter Fréchet Distribution, and to other distributions, but with limited output of the best fit details. See below for details.

Unbinned data
In addition to the above methods used in combination with the appropriate Constructors or Stat binning methods for unbinned data see also the ProbabilityPlot class methods under Fréchet Probability Plots. These methods return best fit estimates of μ, σ and γ.

Fit data to a Weibull Distribution Function [Type 3 Extreme Value Distribution]
NB: The ProbabilityPlot class is likely to be more useful in fitting data to a Weibull distribution.

Fit data to a Three parameter Weibull Distribution Function
public void weibull()
Usage:                      reg.weibull();
This method fits the data to the three parameter Weibull distribution function;

where μ is the location parametera, σ is the scale parameter, γ is the shape parameter and Ao is an ordinate scaling factor. The parameters μ, σ, γ and Ao are the parameters to be estimated. A Nelder and Mead Simplex procedure is used. See Ordinate Scaling Factor Option (above) for the procedure by which the ordinate scaling factor, Ao, may be set to a fixed value, typically 1 or 100. See Constructors and the class Stat for details of Weibull statistical methods and for fitting a data set that has first to be binned into a set of observation frequency bins.

Fit data to a three parameter Weibull Distribution and plot results
public void weibullPlot()
Usage:                      reg.weibullPlot();
Performs all that is described above under reg.weibull() and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed p(x) values versus the calculated p(x) values
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list).

Fit data to a Two parameter Weibull Distribution Function
public void weibullTwoPar()
Usage:                      reg.weibullTwoPar();
This method fits the data to the two parameter Weibull distribution function;

σ is the scale parameter, γ is the shape parameter and Ao is an ordinate scaling factor. The parameters σ, γ and Ao are the parameters to be estimated, i.e. the location parameter, μ has been set to zero. A Nelder and Mead Simplex procedure is used. See Ordinate Scaling Factor Option (above) for the procedure by which the ordinate scaling factor, Ao, may be set to a fixed value, typically 1 or 100. See Constructors and the class Stat for details of Weibull statistical methods and for fitting a data set that has first to be binned into a set of observation frequency bins.

Fit data to a two parameter Weibull Distribution and plot results
public void weibullTwpParPlot()
Usage:                      reg.weibullTwoParPlot();
Performs all that is described above under reg.weibullTwoPar() and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed p(x) values versus the calculated p(x) values
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list).

Fit data to a Standard Weibull Distribution Function
public void weibullStandard()
Usage:                      reg.weibullStandard();
This method fits the data to the standard Weibull distribution function;

γ is the shape parameter and Ao is an ordinate scaling factor. The parameters γ and Ao are the parameters to be estimated, i.e. the location parameter, μ has been set to zero and the scale parameter, σ has been set to unity. A Nelder and Mead Simplex procedure is used. See Ordinate Scaling Factor Option (above) for the procedure by which the ordinate scaling factor, Ao, may be set to a fixed value, typically 1 or 100. See Constructors and the class Stat for details of Weibull statistical methods and for fitting a data set that has first to be binned into a set of observation frequency bins.

Fit data to a Standard Weibull Distribution and plot results
public void weibullStandardPlot()
Usage:                      reg.weibullStandardPlot();
Performs all that is described above under reg.weibullStandard() and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed p(x) values versus the calculated p(x) values
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list).
Static method
The static method (fitOneOrSeveralDistribtions(dataArray)) allows the fitting of the data in the double array, dataArray, to a Three Parameter Weibull Distribution, and to other distributions, but with limited output of the best fit details. See below for details.

Unbinned data
In addition to the above methods used in combination with the appropriate Constructors or Stat binning methods for unbinned data see also the ProbabilityPlot class methods under Weibull Probability Plots. These methods return best fit estimates of μ, σ and γ.

Fit data to a Exponential Distribution
The exponential distribution is a special case of a Weibull distribution in which the shape parameter, γ, has been set to unity.

NB: The ProbabilityPlot class is likely to be more useful in fitting data to an Exponential distribution.

Fit data to a Two parameter Exponential Distribution Function
public void exponential()
Usage:                      reg.exponential();
This method fits the data to the two parameter Exponential distribution function;

where μ is the location parametera, σ is the scale parameter and Ao is an ordinate scaling factor. The parameters μ, σ and Ao are the parameters to be estimated. A Nelder and Mead Simplex procedure is used. See Ordinate Scaling Factor Option (above) for the procedure by which the ordinate scaling factor, Ao, may be set to a fixed value, typically 1 or 100. See Constructors and the class Stat for details of Exponential statistical methods and for fitting a data set that has first to be binned into a set of observation frequency bins.

Fit data to a two parameter Exponential Distribution and plot results
public void exponentialPlot()
Usage:                      reg.exponentialPlot();
Performs all that is described above under reg.exponential() and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed p(x) values versus the calculated p(x) values
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list).

Fit data to a One Parameter Exponential Distribution Function
public void exponentialOnePar()
Usage:                      reg.exponentialOnePar();
This method fits the data to the two parameter Exponential distribution function;

σ is the scale parameter and Ao is an ordinate scaling factor. The parameters σ and Ao are the parameters to be estimated, i.e. the location parameter, μ has been set to zero. A Nelder and Mead Simplex procedure is used. See Ordinate Scaling Factor Option (above) for the procedure by which the ordinate scaling factor, Ao, may be set to a fixed value, typically 1 or 100. See Constructors and the class Stat for details of Exponential statistical methods and for fitting a data set that has first to be binned into a set of observation frequency bins.

Fit data to a one parameter Exponential Distribution and plot results
public void exponentialOneParPlot()
Usage:                      reg.exponentialOneParPlot();
Performs all that is described above under reg.exponentialOnePar() and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed p(x) values versus the calculated p(x) values
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list).

Fit data to a Standard Exponential Distribution Function
public void exponentialStandard()
Usage:                      reg.exponentialStandard();
This method fits the data to the standard Exponential distribution function;

γ is the shape parameter and Ao is an ordinate scaling factor. The parameters γ and Ao are the parameters to be estimated, i.e. the location parameter, μ has been set to zero and the scale parameter, σ has been set to unity. A Nelder and Mead Simplex procedure is used. See Ordinate Scaling Factor Option (above) for the procedure by which the ordinate scaling factor, Ao, may be set to a fixed value, typically 1 or 100. See Constructors and the class Stat for details of Exponential statistical methods and for fitting a data set that has first to be binned into a set of observation frequency bins.

Fit data to a Standard Exponential Distribution and plot results
public void exponentialStandardPlot()
Usage:                      reg.exponentialStandardPlot();
Performs all that is described above under reg.exponentialStandard() and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed p(x) values versus the calculated p(x) values
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list).
Static method
The static method (fitOneOrSeveralDistribtions(dataArray)) allows the fitting of the data in the double array, dataArray, to a Two Parameter Exponential Distribution, and to other distributions, but with limited output of the best fit details. See below for details.

Unbinned data
In addition to the above methods used in combination with the appropriate Constructors or Stat binning methods for unbinned data see also the ProbabilityPlot class methods under Exponential Probability Plots. These methods return best fit estimates of μ and σ.

Fit data to Simple Exponentials
Fit data to a Single Exponential
public void exponentialSimple()
Usage:                      reg.exponentialSimple();
This method fits the data to a Simple Exponential:
yi = A.exp(B.xi)
where B is the exponential decay constant and A is an ordinate scaling factor. The parameters B and A are the parameters to be estimated. A Nelder and Mead Simplex procedure is used. See Ordinate Scaling Factor Option (above) for the procedure by which the ordinate scaling factor, Ao, may be set to a fixed value, typically 1 or 100.

Fit data to a Simple Exponential and plot results
public void exponentialSimplePlot()
Usage:                      reg.exponentialSimplePlot();
Performs all that is described above under reg.exponentialSimple()
and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed y values versus the calculated y values
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list).

Fit data to one minus a single exponential
public void oneMinusExponential()
Usage:                      reg.oneMinusExponential();
This method fits the data to:
yi = A.(1.0 - exp(B.xi))
where B is the exponential decay constant and A is an ordinate scaling factor. The parameters A and B are the parameters to be estimated. A Nelder and Mead Simplex procedure is used.

Fit data to one minus a single exponential and plot results
public void oneMinusExponentialPlot()
Usage:                      reg.oneMinusExponentialPlot();
Performs all that is described above under reg.oneMinusExponential()
and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed y values versus the calculated y values
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list).

Fit data to Multiple Exponentials
Fitting data to sums of exponentials can be difficult as this often involves a very ill-conditioned set of equations. Read the literature on this subject before using these methods if you are not familiar with such fitting and treat the results of these methods with caution. A method is also supplied that enables the user to supply initial estimates instead of relying on the internally calculated initial estimates. This is the preferred method if the user has some knowledge of the model being fitted.

Fit data to Multiple Exponentials with internally calculated initial estimates
public void exponentialMultiple(int nExp)
public void exponential|MultiplePlot(int nExp)
Usage:                      reg.exponentialMultiple(n);
This method fits the data to a sum of n exponentials:

The parameters Aj and Bj are the parameters to be estimated. A Nelder and Mead Simplex procedure is used. The initial estimates are calculated within the method (See below for a method taking user supplied initial estimates).
Use the constraint methods to apply the common constraints on the values of Aj, e.g. for(int j=0; j<2*n; j+=2)reg.addConstraint(j, -1, 0); constrains all Aj to the positive domain,
for(int j=1; j<=2*n; j+=2)reg.addConstraint(j, 1, 0); constrains all Bj to the negative domain.

Fit data to Multiple Exponentials and plot results
public void exponentialMultiplePlot(n)
Usage:                      reg.exponentialMultiplePlot(n);
Performs all that is described above under reg.exponentialMultiple(n)
and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed y values versus the calculated y values
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list).
Fit data to Multiple Exponentials with user supplied initial estimates
public void exponentialMultiple(int nExp, double[] initialEstimates)
public void exponential|MultiplePlot(int nExp, double[] initialEstimates)
Usage:                      reg.exponentialMultiple(n, initialEstimates);
This method fits the data to a sum of n exponentials:

The parameters Aj and Bj are the parameters to be estimated. A Nelder and Mead Simplex procedure is used. The initial estimates are supplied by the user and entered as the argument array, initialEstimates (See above for a method that calculates the initial estimates). Enter the initial estimates in the order A1, B1, A2, B2, . . .
Use the constraint methods to apply the common constraints on the values of Aj, e.g. for(int j=0; j<2*n; j+=2)reg.addConstraint(j, -1, 0); constrains all Aj to the positive domain,
for(int j=1; j<=2*n; j+=2)reg.addConstraint(j, 1, 0); constrains all Bj to the negative domain.

Fit data to Multiple Exponentials and plot results
public void exponentialMultiplePlot(n, initialEstimates)
Usage:                      reg.exponentialMultiplePlot(n, initialEstimates);
Performs all that is described above under reg.exponentialMultiple(n, initialEstimates)
and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed y values versus the calculated y values
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list).

Fit data to a Rayleigh Distribution
The Rayleigh distribution is a special case of a Weibull distribution in which the shape parameter, γ, has been set equal to 2, the location parameter, μ, has been set equal to zero and the Weibull scale paramater, σ has been divided by the square root of 2.

NB: The ProbabilityPlot class is likely to be more useful in fitting data to a Rayleigh distribution.

public void rayleigh()
Usage:                      reg.rayleigh();
This method fits the data to a Rayleigh distribution function;

where β is the scale parameter and Ao is an ordinate scaling factor. The parameters σ and Ao are the parameters to be estimated. A Nelder and Mead Simplex procedure is used. See Ordinate Scaling Factor Option (above) for the procedure by which the ordinate scaling factor, Ao, may be set to a fixed value, typically 1 or 100. See Constructors and the class Stat for details of Rayleigh statistical methods and for fitting a data set that has first to be binned into a set of observation frequency bins.

Fit data to a Rayleigh Distribution and plot results
public void rayleighPlot()
Usage:                      reg.rayleighPlot();
Performs all that is described above under reg.rayleigh() and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed p(x) values versus the calculated p(x) values
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list).
Static method
The static method (fitOneOrSeveralDistribtions(dataArray)) allows the fitting of the data in the double array, dataArray, to a Rayleigh Distribution, and to other distributions, but with limited output of the best fit details. See below for details.

Unbinned data
In addition to the above methods used in combination with the appropriate Constructors or Stat binning methods for unbinned data see also the ProbabilityPlot class methods under Rayleigh Probability Plots. These methods returns a best fit estimate of β.

Fit data to a Pareto Distribution
NB: The ProbabilityPlot class is likely to be more useful in fitting data to a Pareto distribution.

Fit data to a Shifted Pareto Distribution Function
public void paretoShifted()
Usage:                      reg.paretoShifted();
This method fits the data to a shifted Pareto distribution function;

where α is the shape parameter, β is the scale parameter, θ is the threshold parameter and Ao is an ordinate scaling factor. The parameters α, β, θ and Ao are the parameters to be estimated. A Nelder and Mead Simplex procedure is used. See Ordinate Scaling Factor Option (above) for the procedure by which the ordinate scaling factor, Ao, may be set to a fixed value, typically 1 or 100. See Constructors and the class Stat for details of Pareto statistical methods and for fitting a data set that has first to be binned into a set of observation frequency bins.

Fit data to a Shifted Pareto Distribution and plot results
public void paretoShiftedPlot()
Usage:                      reg.paretoShiftedPlot();
Performs all that is described above under reg.paretoShifted() and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed p(x) values versus the calculated p(x) values
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list).
Fit data to a Two Parameter Pareto Distribution Function
public void paretoTwoPar()
Usage:                      reg.paretoTwoPar();
This method fits the data to the Two Parameter Pareto distribution function;

where α is the shape parameter, β is the scale parameter and Ao is an ordinate scaling factor. The parameters α, β and Ao are the parameters to be estimated. A Nelder and Mead Simplex procedure is used. See Ordinate Scaling Factor Option (above) for the procedure by which the ordinate scaling factor, Ao, may be set to a fixed value, typically 1 or 100. See Constructors and the class Stat for details of Pareto statistical methods and for fitting a data set that has first to be binned into a set of observation frequency bins.

The method pareto() is identical to paretoTwoPar() and has been retained to maintain backward compatibility.

Fit data to a Two Parameter Pareto Distribution and plot results
public void paretoTwoParPlot()
Usage:                      reg.paretoTwoParPlot();
Performs all that is described above under reg.pareto() and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed p(x) values versus the calculated p(x) values
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list).
The method paretoPlot() is identical to paretoTwoParPlot() and has been retained to maintain backward compatibility.

Fit data to the One Parameter Pareto Distribution Function
public void paretoOnePar()
Usage:                      reg.paretoOnePar();
This method fits the data to the One Parameter Pareto distribution function;

α is the shape parameter and Ao is an ordinate scaling factor. The parameters α and Ao are the parameters to be estimated, i.e. the scale parameter, β has been set to unity. A Nelder and Mead Simplex procedure is used. See Ordinate Scaling Factor Option (above) for the procedure by which the ordinate scaling factor, Ao, may be set to a fixed value, typically 1 or 100. See Constructors and the class Stat for details of Pareto statistical methods and for fitting a data set that has first to be binned into a set of observation frequency bins.

Fit data to a one parameter Pareto Distribution and plot results
public void paretoOneParPlot()
Usage:                      reg.paretoOneParPlot();
Performs all that is described above under reg.paretoOnePar() and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed p(x) values versus the calculated p(x) values
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list).
Static method
The static method (fitOneOrSeveralDistribtions(dataArray)) allows the fitting of the data in the double array, dataArray, to a Three Parameter Pareto Distribution, and to other distributions, but with limited output of the best fit details. See below for details.

Unbinned data
In addition to the above methods used in combination with the appropriate Constructors or Stat binning methods for unbinned data see also the ProbabilityPlot class methods under Pareto Probability Plots. These methods return best fit estimates of α and β for a two parameter Pareto distribution.

### Fitting data to one or several of the above distributions

public static void fitOneOrSeveralDistributions(double [] array)
Usage:                      Regression.fitOneOrSeveralDistributions(array);
A static method that allows the data passed in the one dimensional array of doubles, array, to be fitted to as many of the following distributions as the user chooses:
• Gaussian Distribution
• Log-normal Distribution (two parameter statistic)
• Log-normal Distribution (three parameter statistic)
• Logistic Distribution
• Lorentzian Distribution
• Type 1 Extreme Distribution - Two Parameter Gumbel minimum order statistic
• Type 1 Extreme Distribution - Two Parameter Gumbel maximum order statistic
• Type 2 Extreme Distribution - Three Parameter Frechet
• Type 3 Extreme Distribution - Three Parameter Weibull
• Type 3 Extreme Distribution - Two Parameter Exponential Distribution
• Type 3 Extreme Distribution - Rayleigh Distribution
• Three Parameter Pareto Distribution
• Beta Distribution on the interval [min, max]
• Three Parameter Gamma Distribution
• Erlang Distribution
The choice/s are made via a dialog box.
The method calculates a suggested bin width which may be altered via a dialog box.
Two plots for each chosen distribution are displayed:
1. The binned data frequencies with the best fit curve of the chosen distribution;
2. The binned frequences against the expected frequencies for the chosen distribution.
The output text file (tab separated variables) lists:
• File name
• Date and time of file creation
• Number of data points
• Minimum value
• Maximum value
• Bin width
• Average number of points per bin
and for each distribution chosen:
• Distribution name
• Best Estimates of the fitted parametrs, e.g. of the mean, location parameter, shape parameter, scaling parameter
• Value of chi squared
• Value of reduced chi squared
• Value of sum of squares
• Degrees of freedom
• Number of iterations taken
• Maximum number of iterations allowed

### Fit to Sigmoid Functions

Fit to a Sigmoidal Threshold Function
public void sigmoidThreshold()
Usage:                      reg.sigmoidThreshold();
This method fits the data to the Sigmoidal Threshold Function:

where α is the slope parameter, θ is x value (abscissa) at the mid point of the threshold and Ao is an ordinate scaling factor. The slope parameter, α, is related to the maximum gradient at the threshold by the equation

The parameters α, θ and Ao are the parameters to be estimated. A Nelder and Mead Simplex procedure is used. See Ordinate Scaling Factor Option (above) for the procedure by which the ordinate scaling factor, Ao, may be set to a fixed value, typically 1 or 100.

Fit data to a Sigmoidal Threshold Function and plot results
public void sigmoidThresholdPlot()
Usage:                      reg.sigmoidThresholdPlot();
Performs all that is described above under reg.sigmoidThreshold()
and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed y values versus the calculated y values
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details and the value of the maximum gradient (see print for detailed output list).

Fit to a Hill/Sips Sigmoidal Function
public void sigmoidHillSips()
Usage:                      reg.sigmoidHillSips();
This method fits the data to the Hill/Sips Sigmoidal Function:

where n is the slope parameter, θ is x value (abscissa) at the mid point of the sigmoid ordinates and Ao is an ordinate scaling factor. The parameters n, θ and Ao are the parameters to be estimated. A Nelder and Mead Simplex procedure is used. See Ordinate Scaling Factor Option (above) for the procedure by which the ordinate scaling factor, Ao, may be set to a fixed value, typically 1 or 100. The slope parameter, n, is related to the maximum gradient at the threshold by the equation

This is a generalised form of the Hill Equation (protein-ligand interactions) and the Sips Equation (antibody-hapten interactions). If y is equated to the fractional saturation and x is equated to the free ligand/hapten, the Hill/Sips constant, Ka, is equal to θn, the Hill cooperativity index or the Sips heterogeneity index is equal to n and the number of sites is equal to Ao.

Fit data to a Hill/Sips Sigmoidal Function and plot results
public void sigmoidHillSipsPlot()
Usage:                      reg.sigmoidHillSipsPlot();
Performs all that is described above under reg.sigmoidHillSips()
and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed y values versus the calculated y values
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details and the value of the Hill/Sips Ka (see print for detailed output list).

Fit to a five parameter logistic curve (5PL)
See also ImmunoAssay.
public void fiveParameterLogistic()
public void fiveParameterLogistic(double bottom, double top)
Usage:                      reg.fiveParameterLogistic();
This method fits the data to the five parameter logistic curve:

The parameters top, bottom, C50, HillSlope and asymm are the parameters to be estimated. A Nelder and Mead Simplex procedure is used.

Usage:                      reg.fiveParameterLogistic(bottom, top);
As above for fiveParameterLogistic() with the exception that the parameters, bottom and top, are fixed to the respective argument values, i.e. EC50, HillSlope and asymm are the parameters to be estimated.

Fit data to a five parameter logistic curve (5PL) and plot results
See also ImmunoAssay.
public void fiveParameterLogisticPlot(double bottom, double top)
Usage:                      reg.fiveParameterLogisticPlot();
Performs all that is described above under reg.fiveParameterLogistic()
and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed y values versus the calculated y values
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list).
Usage:                      reg.fiveParameterLogisticPlot(bottom, top);
As above for fiveParameterLogisticPlot() with the exception that the parameters, bottom and top, are fixed to the respective argument values, i.e. C50, HillSlope and asymm are the parameters to be estimated.

Fit to a four parameter logistic curve (4PL, EC50 dose response curve)
See also ImmunoAssay.
public void fourParameterLogistic()
public void ec50()
public void fourParameterLogisticConstrained()
public void ec50constrained()
public void fourParameterLogistic(double bottom, double top)
public void ec50(double bottom, double top)
Usage:                      reg.fourParameterLogistic();
Usage:                      reg.ec50();
These identical methods fit the data to the four parameter logistic curve (EC50 dose response curve):

The parameters top, bottom, EC50 and HillSlope are the parameters to be estimated. A Nelder and Mead Simplex procedure is used.

Usage:                      reg.fourParameterLogisticConstrained();
Usage:                      reg.ec50constrained();
As above for fourParameterLogistic() with the exception that the best estimate of the parameter, bottom, is constrained to be either zero or a positive value.

Usage:                      reg.fourParameterLogistic(bottom, top);
Usage:                      reg.ec50(bottom, top);
As above for fourParameterLogistic() with the exception that the parameters, bottom and top, are fixed to the respective argument values, i.e. EC50 and HillSlope are the parameters to be estimated.

Fit data to a four parameter logistic curve (4PL, EC50 dose response curve) and plot results
See also ImmunoAssay.
public void fourParameterLogisticPlot()
public void ec50Plot()
public void fourParameterLogisticConstrainedPlot()
public void ec50constrainedPlot()
public void fourParameterLogisticPlot(double bottom, double top)
public void ec50Plot(double bottom, double top)
Usage:                      reg.fourParameterLogisticPlot();
Usage:                      reg.ec50Plot();
Performs all that is described above under reg.fourParameterLogistic() (reg.ec50())
and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed y values versus the calculated y values
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list).
Usage:                      reg.ec50constrainedPlot();
As above for fourParameterLogisticPlot() with the exception that the best estimate of the parameter, bottom, is constrained to be either zero or a positive value.

Usage:                      reg.fourParameterLogisticPlot(bottom, top);
Usage:                      reg.ec50plot(bottom, top);
As above for fourParameterLogisticPlot() with the exception that the parameters, bottom and top, are fixed to the respective argument values, i.e. EC50 and HillSlope are the parameters to be estimated.

Fit data to a Scaled Heaviside Step Function
public void stepFunction()
Usage:                      reg.stepFunction();
This method fits the data to a Scaled Heaviside Step Function:

where θ is x value (abscissa) at the mid point of the ordinates and Ao is an ordinate scaling factor. The parameters θ and Ao are the parameters to be estimated. A Nelder and Mead Simplex procedure is used. See Ordinate Scaling Factor Option (above) for the procedure by which the ordinate scaling factor, Ao, may be set to a fixed value, typically 1 or 100.

Fit data to a Scaled Heaviside Step Function and plot results
public void stepFunctionPlot()
Usage:                      reg.stepFunctionPlot();
Performs all that is described above under reg.stepFunction()
and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed y values versus the calculated y values
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list).

Fit data to a Rectangular Hyperbola
public void rectangularHyperbola()
public void shiftedRectangularHyperbola()
Usage:                      reg.rectangularHyperbola();
This method fits the data to a Rectangular Hyperbola:

where θ is x value (abscissa) at the mid point of the ordinates and Ao is an ordinate scaling factor. The parameters θ, Ao and are the parameters to be estimated. A Nelder and Mead Simplex procedure is used. See Ordinate Scaling Factor Option (above) for the procedure by which the ordinate scaling factor, Ao, may be set to a fixed value, typically 1 or 100.

Usage:                      reg.shiftedRectangularHyperbola();
This method fits the data to a shifted Rectangular Hyperbola:

The parameters θ, α and Ao are the parameters to be estimated. A Nelder and Mead Simplex procedure is used.

Fit data to a Rectangular Hyperbola and plot results
public void rectangularHyperbolaPlot()
public void shiftedRectangularHyperbolaPlot()
Usage:                      reg.rectangularHyperbolaPlot();
Performs all that is described above under reg.rectangularHyperbola()
and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed y values versus the calculated y values
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list).
Usage:                      reg.shiftedectangularHyperbolaPlot();
Performs all that is described above under reg.shiftedRectangularHyperbola()
and in addition
• displays a plot of the data and best fit line
• displays a plot of the observed y values versus the calculated y values
• outputs a text file of best estimates of the coefficients, linear approximations of their standard deviations, t-values, p-values, observed and calculated data values, the regression statistics and the termination details (see print for detailed output list).

### COMMON METHODS

THE INUT DATA OPTIONS
Set the weighting error type
public void setErrorsAsScaled()
Usage:                      reg.setErrorsAsScaled();
The y measurement errors and the x measurement errors entered via a constructor are used as weights in the weighted regressions and in the calculation of the errors associated with the best estimates of the unknown parameters. They should be estimates of the standard deviation of the corresponding y or x data value. If they are simply entered not as estimates of the standard deviation but as arbitrary weights that are internally consistent, i.e. as scaled estimates of the standard deviations, the regression will be unaffected by the scaling factor but the best estimate standard errors will be calculated incorrectly. If you are entering scaled errors as weights you must call this method. The default method of this class is to assume the entered errors are estimates of the standard deviations. Calling this method overrides this assumpltion. Instead, in the calcultion of the best estimate standard errors, the weights are scaled to approximate to standard deviation estimates, using the variance of the obsesrvation.

public void setErrorsAsSD()
Usage:                      reg.setErrorsAsSD();
This method resets the best estimate error calculation option to the default option, i.e. assuming entered experimental errors are estimates of the standard deviation.

Set the input data option for data entere as frequencies
public void setTrueFreq(boolean trueOrfalse)
Usage:                      reg.setTrueFreq(trueOrFalse);
If the data are true unscaled frequencies, e.g. in fitting frequency data to a Gaussian, one may set this method's argument [trueOrFalse in the above usage] to true. Chi square will then be calculated as

and not as

i.e. the weighting factors are set to the square root of the frequency of observation, i.e. a Poissonian distribution is assumed in the measurement of the frequency of a particular observation. See
getChiSquare for further details. The default value is false.

public boolean getTrueFreq()
Usage:                      opt = reg.getTrueFreq();
Returns the data input option (see immediately above for details).

ADD A TITLE TO THE GRAPHS AND OUTPUT FILE
public void setTitle(String title)
Usage:                      reg.setTitle(gtitle);
Adds the String argument gtitle, as a title, to the plots and the output file.

PRINT THE REGRESSION RESULTS
public void print( String filename, int prec)
public void print( String filename)
public void print(int prec)
public void print()
Usage:                      reg.print(filename, prec);
Outputs a time and date stamped text file, whose name is in the String filename, to which is written:
• the regression procedure
• whether the regression is a weighted or unweighted least squares minimisation
• the best estimates of the unknown parameters
• the estimates of their standard errors
In the case of a non-linear regression these are obtained from the covariance matrix, calculated from difference equations, that assume a linear model and therefore must be treated with caution
• the t-values for the best estimates
• the P-values for the best estimates
• the coefficients of variation
• the minimisation surface gradients either side of the minimum [non-linear regression only]
• the initial estimates [non-linear regression only]
• x values, observed y values, calculated y values, weights, residuals, weighted residuals
• unweighted sum of squares
• weighted sum of squares [only if weights or true frequencies have been provided]
• The linear correlation coefficient between x(observed) and y(observed) [only if one x-data array]
• The linear correlation coefficient between y(observed) and y(calculated)
• coefficient of determination
• adjusted coefficient of determination
• coefficient of determination F-ratio
• coefficient of determination F-ratio probability
• the number of degrees of freedom
• the number of data points
• the number of unknown parameters
• the estimates of the correlation coefficients between estimated parameters
• the Durbin-Watson d statistic
• the number of iterations [non-linear regression only]
• the maximum number of iterations allowed [non-linear regression only]
• the number of restarts [non-linear regression only]
• the maximum number of restarts allowed [non-linear regression only]
• the standard deviation of the simplex at the minimum [non-linear regression only]
• the convergence tolerance [non-linear regression only]
• the convergence test option used [non-linear regression only]
• the fractional step used in difference equations [non-linear regression only]
• a history of the search for the best polynomial is listed here if this print method is called from a bestPolynomial method
All floating point outputted values have had their mantissae truncted and rounded to prec decimal places. No truncation occurs if a minus value is assigned to prec

Usage:                      reg.print(filename);
Outputs a time and date stamped text file, whose name is in the String filename, to which is written the same data has listed above. A default option of 4 decimal places is used in the truncation and rounding method.

Usage:                      reg.print(prec);
Outputs a time and date stamped text file, called RegressionOutputN, to which is written the same data has listed above. The file name final integer, N is incremeted by 1 on creating a new file without having deleted the previous one. The argument prec has the same meaning as above.

Usage:                      reg.print();
Outputs a time and date stamped text file, called RegressionOutputN, to which is written the same data has listed above. The file name final integer, N is incremeted by 1 on creating a new file without having deleted the previous one. A default option of 4 decimal places is used in the truncation and rounding method.

SUPPRESS THE PRINTING OF THE REGRESSION RESULTS
public void suppressPrint()
Usage:                      reg.suppressPrint();
Suppresses the automatic printing of the regression results in methods of the general name xxxxPlot(), e.g. linearPlot(), simplexPlot(...)

PLOT THE REGRESSION RESULTS (x versus y)
Linear Regression
public int plotXY( String graphname)
public int plotXY()
Usage:                      reg.plotXY(graphname);
Displays a plot of the x values against the observed y values with the best fit line drawn. The plot has the String graphname as its title. If an attempt is made to plot a multiple linear regression, an error message is displayed and the observed versus calculated y values are plotted instead [see plotYY below]
Usage:                      reg.plotXY();
As immediately above [plotXY(graphname)] but no name is given to the graph.

Non-Linear Regression
public int plotXY(RegressionFunction rf, String graphname)
public int plotXY(RegressionFunction2 rf, String graphname)
public int plotXY(RegressionFunction3 rf, String graphname)
public int plotXY(RegressionFunction rf)
public int plotXY(RegressionFunction2 rf)
public int plotXY(RegressionFunction3 rf)
Usage:                      reg.plotXY(rf, graphname);
Displays a plot of the x values against the observed y values with the best fit line drawn, if simplex has been previously called. The plot has the String graphname as its title. For plotting non-linear regression results, the function to which the data has been fitted must be passed as the appropriate Regession Function, rf in the above usage. If an attempt is made to plot a multiple non-linear regression, an error message is displayed; see plotYY below for an alternative plot of y calculated against y observed.
Usage:                      reg.plotXY(g);
As immediately above [plotXY(rf, graphname)] but no title name is given to the graph.

PLOT THE REGRESSION RESULTS (y observed versus y calculated)
public int plotYY(String graphname)
public int plotYY()
Usage:                      reg.plotYY(graphname);
Displays a plot of the observed y values against the calculated y values. A best fit straight line is drawn through the points. The plot has the String graphname as its title.
Usage:                      reg.plotYY();
As immediately above [plotYY(graphname)] but no name is given to the graph.

SUPPRESS THE PLOT OF y OBSERVED VERSUS y CALCULATED
public void suppressYYplot()
Usage:                      reg.suppressYYplot();
Suppresses the automatic plotting of the observed value of y abgainst the calculated value of y in methods of the general name xxxxPlot(), e.g. linearPlot(), simplexPlot(...)

ADD LEGENDS TO THE AXES OF THE x VERSUS y PLOTS
public void setXlegend(String xLegend)
public void setYlegend(String yLegend)
Usage:                      reg.setXlegend(xLegend);
Adds the legend, xLegend, to the x-axis (abscissa) of the x-y plots. The default option is "x axis values".

Usage:                      reg.setYlegend(yLegend);
Adds the legend, yLegend, to the y-axis (ordinate) of the x-y plots. The default option is "y axis values".

RETURN THE BEST ESTIMATES
public double[] getBestEstimates()
Usage:                      coeff = reg.getBestEstimates();
Returns the best estimates of the unknown parameters, a[0], a[1], a[2] . . .

RETURN THE ERRORS OF THE BEST ESTIMATES
public double[] getBestEstimatesErrors()
Usage:                      coeffSd = reg.BestEstimatesErrors();
Returns the estimates of the errors of the best estimates of the unknown parameters.
If the regression was a non-linear regression, these have been obtained by obtaining the Hessian matrix, and inverting this to obtain the covariance matrix, from the partial second derivatives of either chi square or the sum of squares with respect to all pairs of estimated parameters calculated as difference equations. As this assumes that the model behaves as a linear model close to the minimum of chi square or the sum of squares, these statistical results, in the case of a non-linear model, should be treated with great caution.

RETURN THE COEFFICIENTS OF VARIATION
public double[] getCoeffVar()
Usage:                      coeffVar = reg.getCoeffVar;
Returns the coefficients of variation, i.e. the estimated error of each estimated parameter divided by the best estimate expressed as a percentage (multiplied by 100).
If the regression was a non-linear regression, these have been obtained by first obtaining the Hessian matrix, and inverting this to obtain the covariance matrix, from the partial second derivatives of either chi square or the sum of squares with respect to all pairs of estimated parameters calculated as difference equations. As this assumes that the model behaves as a linear model close to the minimum of chi square or the sum of squares, these statistical results, in the case of a non-linear model, should be treated with great caution.

RETURN THE t-VALUES OF THE BEST ESTIMATES
public double[] getTvalues()
Usage:                      tvalues = reg.getTvalues();
Returns the the t-values of the best estimates of the unknown parameters, a[0], a[1], a[2] . . .,
The t-value, t, is defined as
t = the best estimate divided by its standard error
and is calculated as
t = the best estimate divided by the estimate of its error.

RETURN THE P-VALUES OF THE BEST ESTIMATES
public double[] getPvalues()
Usage:                      tvalues = reg.getPvalues();
Returns the the P-values (P > |t|) of the best estimates of the unknown parameters, a[0], a[1], a[2] . . .
The P-values are calculated as

where the t-value, t, is defined immediately above and the definition of the other symbols and details of the calculation of the integral may be found in the Student's t methods documentation in the Stat class.

RETURN THE CALCULATED y VALUES
public double[] getYcalc()
Usage:                      yCalcf = reg.getYcalc();
Returns the calculated values of the y-value, using the best estimates.

RETURN THE WEIGHTS
public double[] getWeights()
Usage:                      weights = reg.getWeights();
Returns the current values of the weights. If the weights were entered simply as y measurement errors these, or their scaled values if method serErrorsAsScaled() has been called, will be returned. If they were entered as both x and y measurements the propagated errors used as weights will be returned.

RETURN THE UNWEIGHTED RESIDUALS
public double[] getResiduals()
Usage:                      resid = reg.getResiduals();
Returns the unweighted residuals, y(observed) - y(calculated using the best estimates).

RETURN THE WEIGHTED RESIDUALS
public double[] getWeightedResiduals()
Usage:                      residW = reg.getWeightedResiduals();
Returns the weighted residuals, (y(observed) - y(calculated))/(weighting factor).

RETURN THE SUM OF SQUARES OF THE UNWEIGHTED RESIDUALS
public double getSumOfSquares()
public double getSumOfUnweightedResidualSquares()
Usage:                      ss = reg.getSumOfSquares();
ss = reg.getSumOfUnweightedResidualSquares();
Returns the sum of the squares, ss:

where the array observed contains the experimental y values and array calculated contains the y values calculated using the best estimates, for all data points, n.
The two methods are identical in fuction.

RETURN THE SUM OF SQUARES OF THE WEIGHTED RESIDUALS
public double getChiSquare()
public double getSumOfWeightedResidualSquares()
Usage:                      chi = reg.getChiSquare();
ss = reg.getSumOfWeightedResidualSquares();
Returns the weighted sum of the squares, ss:

for all n data points, i.e. an estimate of Chi Square:

where the array observed holds the experimental y values, the array calculated holds the y values calculated using the parameter best estimates, weight holds the supplied weighting factors whose squares, ideally, should be the variances of the experimental data points.
If the data is a distrubution of unscaled frequency measurements (see setTrueFreq), chi square is then calculated as

where the array observedFreq holds the observed frequency of a values occuring with the ith bin, the array expectedFreq holds the corresponding expected frequency values, where the expected frequency as been equated to the calculated y values.
If the data is unweighted the sum of squares of the unweighted residuals is returned.
The two methods are identical in fuction.

RETURN THE REDUCED CHI SQUARE
public double getReducedChiSquare()
Usage:                      redChi = reg.getReducedChiSquare();
Returns an estimate of the reduced chi square, i.e. the chi square divided by the degrees of freedom, calculated using the best estimates for weighted data. The chi square is calculated as described above under getChiSquare().
If the data is unweighted the reduced sum of unweighted residuals is returned.

RETURN THE TOTAL SUM OF WEIGHTED SQUARES
public double getTotalSumOfWeightedSquares()
Usage:                      ss = reg.getTotalSumOfWeightedSquares();
Returns the total sum of the squares, ss:

for all data points, calculated using the best estimates.
If no weights, w, have been entered the weights are set to unity.

RETURN THE REGRESSION SUM OF WEIGHTED SQUARES
public double getRegrnSumOfWeightedSquares()
Usage:                      ss = reg.getRegrnSumOfWeightedSquares();
Returns the regression sum of the squares, ss:

for all data points, calculated using the best estimates.
If no weights have been entered the weights are set to unity.

RETURN THE LINEAR CORRELATION COEFFICIENT
public double getYYcorrCoeff()
public double getXYcorrCoeff()
Usage:                      corrR = reg.getYYcorrCoeff();
Returns the linear correlation coefficient for the experimental y-data and the calculated y-data.

Usage:                      corrR = reg.getXYcorrCoeff();
Returns the linear correlation coefficient for the experimental x and the experimental y data. This is only calculated if there is a single array of x-data and a single array of y-data, otherwise NaN is returned.

RETURN THE COEFFICIENT OF DETERMINATION
public double getCoefficientOfDetermination()
Usage:                      codR = reg.getCoefficientOfDetermination();
Returns the coefficient of determination, R2:

The error sum of squares is an alternative name for the sum of squares of the residuals.
The sum of squares are weighted if weights have been entered.

RETURN THE ADJUSTED COEFFICIENT OF DETERMINATION
public double getCoefficientOfDetermination()
Usage:                      adjR = reg.getAdjustedCoefficientOfDetermination();
Returns the adjusted coefficient of determination, R2adj:

R2 is calculated as described immediately above, n is the number of data points and p is the number of parameters.

RETURN THE COEFFICIENT OF DETERMINATION F-RATIO
public double getCoeffDeterminationFratio()
Usage:                      codF = reg.getCoeffDeterminationFratio();
Returns the F-ratio, F:

R2 is calculted as described above, n is the number of data points and p is the number of parameters.

RETURN THE COEFFICIENT OF DETERMINATION F-RATIO PROBABILTY
public double getCoeffDeterminationFratioProb()
Usage:                      codP = reg.getCoeffDeterminationFratioProb();
Returns the F-ratio probabilty, P(F), for the above calculated F-ratio, for degrees of freedom, number of unknown parameters and number of data points - number of unknown parametrs - 1.
See F-distribution for details of F-ratio probability calculations.

RETURN THE DEGREES OF FREEDOM
public int getDegFree()
Usage:                      df = reg.getDegFree();
Returns the degrees of freedom, i.e. number of data points - number of estimated parameters

THE COVARIANCE MATRIX
The returned covariance matrix is a true variance-covariance matrix for all linear regressions. It is a pseudo-linear approximation for all non-linear regressions obtained from the inverse of the Hessian matrix in which the second partial differentials are calculated numerically.

Return the Covariance Matrix
public double[][] getCovMatrix()
Usage:                      cov = reg.getCovMatrix();
Returns the variance-covariance matrix (covariance matrix).
If the regression was a non-linear regression, the covariance matrix has been obtained from the inverse of the Hessian matrix in which the partial second derivatives of either chi square or the sum of squares with respect to all pairs of estimated parameters were calculated as difference equations. As this procedure assumes that the model behaves as a linear model close to the minimum of chi square or the sum of squares, the statistical analysis, in the case of a non-linear model, should be treated with great caution.

Set the fractional step size for difference formulae [non-linear regression]
public void setDelta(double delta)
Usage:                      reg.setDelta(delta);
Resets the fractional step size, δ, [delta in the above usage] by which a parameter is incremented or decremented, used in calculating the first and second differentil, by a difference formula, needed to form the Hessian which is inverted to give the linear approximation to a covariance matrix in the nonlinear regression, e.g.

The default value of δ is 1e-4.

Get the fractional step size for difference formulae [non-linear regression]
public doubled getDelta()
Usage:                      delta = reg.getDelta();
Returns the fractional step size, δ, by which a parameter is incremented or decremented, used in calculating the first and second differential, by a difference formula [see immediately above], needed to form the Hessian which is inverted to give the linear approximation to a covariance matrix in the nonlinear regression.

Return the Hessian Matrix Inversion Check [non-linear regression]
public boolean getInversionCheck()
Usage:                      flag = reg.getInersionCheck();
Returns true if the regression is linear or if, in the case of a non-linear regression, inversion of the Hessian Matrix, to obtain the Covariance Matrix, was successful. Returns false if the latter inversion failed.

Return the Covariance Matrix Diagonal Check [non-linear regression]
public boolean getPosVarCheck()
Usage:                      flag = reg.getPosVarCheck();
Returns true if the regression is linear or if, in the case of a non-linear regression, all diagonal elements of the Covariance Matrix, i.e. the variances, are positive. Returns false if any are negative.

RETURN THE PARAMETER CORRELATION COEFFICIENTS
public double[][] getCorrCoeffMatrix()
Usage:                      cov = reg.getCorrCoeffMatrix();
Returns the matrix of sample correlation coefficients between the estimated parameters.
If the regression was a non-linear regression, these have been obtained by first obtaining the Hessian matrix, and inverting this to obtain the covariance matrix, from the partial second derivatives of either chi square or the sum of squares with respect to all pairs of estimated parameters calculated as difference equations. As this assumes that the model behaves as a linear model close to the minimum of chi square or the sum of squares, these statistical results, in the case of a non-linear model, should be treated with great caution.

RETURN THE DURBIN-WATSON d STATISTIC
public double[] getDurbinWatsonD()
Usage:                      dwd = reg.getDurbinWatsonD();
Returns the Durbin-Watson d statistic, used to detect the presence of autocorrelation,

where ei is the ith unweighted residual, y(experimental) - y(calculated using the best estimates), and n is the number of data points.

CHECK NORMALITY OF THE RESIDUALS
public void[] checkResidualNormality()
Usage:                      reg.checkResidualNormality();
Pereforms a check of departure from normality in the distribution of the residuals as described under the method fullAnalysis in the Normality class.

public void[] checkWeightedResidualNormality()
Usage:                      reg.checkWeightedResidualNormality();
Pereforms a check of departure from normality in the distribution of the weighted residuals as described under the method fullAnalysis in the Normality class.

TEST OF ADDITIONAL TERMS [EXTRA SUM OF SQUARES TEST]
public static ArrayList<Object> testOfAdditionalTerms(double chiSquare1, int nParameters1, double chiSquare2, int nParameters2, int nPoints, double significanceLevel)
public static ArrayList<Object> testOfAdditionalTerms(double chiSquare1, int nParameters1, double chiSquare2, int nParameters2, int nPoints)
public static ArrayList<Object> testOfAdditionalTerms_ArrayList(double chiSquare1, int nParameters1, double chiSquare2, int nParameters2, int nPoints, double significanceLevel)
public static ArrayList<Object> testOfAdditionalTerms_ArrayList(double chiSquare1, int nParameters1, double chiSquare2, int nParameters2, int nPoints)

Usage:                      ArrayList<Object> arrayl = Regression.testOfAdditionalTerms(chiSquareR, nParametersR, chiSquareF, nParametersF, nPoints, significanceLevel);
Usage:                      ArrayList<Object> arrayl = Regression.testOfAdditionalTerms(chiSquareR, nParametersR, chiSquareF, nParametersF, nPoints);

Usage:                      ArrayList<Object> arrayl = Regression.testOfAdditionalTerms_ArrayList(chiSquareR, nParametersR, chiSquareF, nParametersF, nPoints, significanceLevel);
Usage:                      ArrayList<Object> arrayl = Regression.testOfAdditionalTerms_ArrayList(chiSquareR, nParametersR, chiSquareF, nParametersF, nPoints);

This method allows the user to test which of two models provides the best fit to the same set of data. The argument chiSquareR is the chi-square value obtained for a regression to the model with the fewer parameters, i.e. the reduced model, and nParametersR is the number of parameters in this reduced model. The argument chiSquareF is the chi-square value obtained for a regression to the model with the additional parameters, i.e. the fuller model, and nParametersF is the number of parameters in this fuller model. The argument nPoints is the number of data points. If the chi-squared values are not available, i.e. the regressions were not weighted, the chi-square values may be replaced by the relevant sums of squares of the residuals. The optional argument, significanceLevel, is the significance level at which the F-ratio needed for the comparison is calculated. If this argument is not entered a default value of 0.05 (5%) is used.
The methods Regression.testOfAdditionalTerms and Regression.testOfAdditionalTerms_ArrayList perform the same functions.

The elements of the returned ArrayList arrayl are:
• The F-ratio, as a Double object,

for a comparison of weighted regressions, where Ndata is the number of data points, nfuller is the number of parameters in the fuller model and nreduced is the number of parameters in the reduced model
or

for a comparison of unweighted regressions (extra sum of squares test), where ss is the sum of squares of the residuals.

• The F distribution probabilty, as a Double object,
PF(F; nfuller - nreduced, Ndata - nfuller)

• A Boolean object that contains a boolean variable indicating whether the chiSquareR and chiSquareF have been reversed by the testOfAdditionalTerms method. This reversal occurs if a chiSquareR with fewer degrees of freedom than chiSquareF has been accidently entered. If this reversal has occurred the boolean is returned as true, if it has not, the boolean is returned as false.

• The reduced model chi-square or sum of squares actually used, as a Double object,

• The reduced model number of parameters actually used, as a Integer object,

• The fuller model chi-square or sum of squares actually used, as a Double object,

• The fuller model number of parameters actually used, as a Integer object,

• The number of data points actually used, as a Integer object,

• The value of the F-ratio at the chosen significance level, as a Double object,

• The value of the chosen significance level, as a Double object,

public static double testOfAdditionalTermsFratio(double chiSquare1, int nParameters1, double chiSquare2, int nParameters2, int nPoints)
Usage:                      fRatio = Regression.testOfAdditionalTermsFratio(chiSquareR, nParametersR, chiSquareF, nParametersF, nPoints);
This method also allows the user to test which of two models provides the best fit to the same set of data. The argument chiSquareR is the chi-square value obtained for a regression to the model with the fewer parameters, i.e. the reduced model, and nParametersR is the number of parameters in this reduced model. The argument chiSquareF is the chi-square value obtained for a regression to the model with the additional parameters, i.e. the fuller model, and nParametersF is the number of parameters in this fuller model. The argument nPoints is the number of data points. If the chi-squared values are not available, i.e. the regressions were not weighted, the chi-square values may be replaced by the relevant sums of squares of the residuals.

This method returns only the F-ratio, as a double primitive variable (symbols as above):

for a comparison of weighted regressions
or

for a comparison of unweighted regressions (extra sum of squares test)

public static double testOfAdditionalTermsFprobability(double chiSquare1, int nParameters1, double chiSquare2, int nParameters2, int nPoints)
Usage:                      fProb = Regression.testOfAdditionalTermsFprobablity(chiSquareR, nParametersR, chiSquareF, nParametersF, nPoints);
This method also allows the user to test which of two models provides the best fit to the same set of data. The argument chiSquareR is the chi-square value obtained for a regression to the model with the fewer parameters, i.e. the reduced model, and nParametersR is the number of parameters in this reduced model. The argument chiSquareF is the chi-square value obtained for a regression to the model with the additional parameters, i.e. the fuller model, and nParametersF is the number of parameters in this fuller model. The argument nPoints is the number of data points. If the chi-squared values are not available, i.e. the regressions were not weighted, the chi-square values may be replaced by the relevant sums of squares of the residuals.

This method returns only the F-distribution probabilty, as a double primitive variable (symbols as above):
PF(F; nfuller - nreduced, Ndata - nfuller)

SETTING THE DENOMINATOR IN STATISTICAL FORMULAE
public static void setDenominatorToN()
Usage:                      Regression.setDenominatorToN();
Sets the denominator of the variance, covariance or standard deviation to the number of data points, n, e.g.

The default value is (n − 1) unless this has been reset by the Stat class static method, setStaticDenominatorToN().

public static void setDenominatorToNminusOne()
Usage:                      Regression.setDenominatorToNminusOne();
Sets the denominator of the variance, covariance or standard deviation to the number of data points minus one, (n − 1), e.g.

The is the default value and this method need only be called if the above method (set to n) or the Stat class static method, setStaticDenominatorToN(), has already been called and a reset to (n − 1) is required.

RESET THE Stat CLASS CONTINUED FRACTION CALCULATION PARAMETERS
The Stat class regularised incomplete beta function evaluation is called by the Regression class statistical analyses, e.g. in the calculation of p-values. The Stat class regularised incomplete beta function, in turn, calls the Stat contFract method which evaluates a relevant continued fraction. These methods allow the user to reset the default values of the tolerance and maximum number of iterations used in terminating the continued fraction evaluation. These need only be called if there is an indication that the default values may not be appropriate, e.g. via a Stat class warning message.

public static void resetCFmaxIter(int maxit)
Usage:                      Regression.resetCFmaxIter(maxit);
Resets the value of the maximum number of iterations, maxit, allowed in the evaluation of the continued fraction (method contFract) needed in the evaluation of the regularised incomplete beta function (Stat class). The default value is 500.

public static int getCFmaxIter()
Usage:                      maxit = Regression.getCFmaxIter();
Returns the value of the maximum number of iterations, maxit, allowed in the evaluation of the continued fraction (method contFract) needed in the evaluation of the regularised incomplete beta function (Stat class). The default value is 500.

public static void resetCFtolerance(double tolerance)
Usage:                      Regression.resetCFtolerance(tolerance);
Resets the value of the tolerance, tolerance, used to terminate the evaluation of the continued fraction (method contFract) needed in the evaluation of the regularised incomplete beta function (Stat class).The default value is 1.0x10-8.

public static double getCFtolerance()
Usage:                      tolerance = Regression.getCFtolerance();
Returns the value of the tolerance, tolerance, used to terminate the evaluation of the continued fraction (method contFract) needed in the evaluation of the regularised incomplete beta function (Stat class).The default value is 1.0x10-8.

### EXAMPLE PROGAMS

• The following example program, RegressionExampleOne, fits data to the function
y = a + b.exp(-c.x)
where the constants, a and c, are the unknown parameters whose best estimates are to be obtained by the regression. The constant b is known and equals 8.0.
The test data was generated for values of a = 3.0 and c = 0.5 and white noise, with a standard devaiation of 0.5, was added to the generated y values.
This example uses the interface RegressionFunction and the constructor Regression(double[] xdata, double[] ydata, double[] weights).
Compiling and running this application will;
• display plots of both the experimental y values and the calculated values y for the best estimates of a and c against the x values;
• display a plots of the experimental y values against the calculated values y for the best estimates of a and c;
• create a text file, RegressionOutputn.txt, listing the results of the regression.
Source file: RegressionExampleOne.java

• The following example program, RegressionExampleTwo, fits data to the function
y = a + b.exp(-c.x) + g z
where the constants, a, c and g, are the unknown parameters whose best estimates are to be obtained by the regression, y is the dependent variable and x and z are the independent variables. The constant b is known and equals 8.0.
The test data was generated for values of a = 3.0, c = 0.5 and g = 3.0 and white noise, with a standard devaiation of 0.25, was added to the generated y values.
This example uses the interface RegressionFunction and the constructor Regression(double[][] xdata, double[] ydata, double[] weights).
Compiling and running this application will;
• display a plot the experimental y values against the calculated values y for the best estimates of a and c;
• create a text file, RegressionOutputn.txt, listing the results of the regression.
Source file: RegressionExampleTwo.java

• The following example program, RegressionExampleThree, fits data to the function
y = a + b.exp(-c.x) + f.exp(-g.z)
where the constants, b, c, f and g, are the unknown parameters whose best estimates are to be obtained by the regression, y is the dependent variable and x and z are the independent variables. The constant a is known and equals 3.0.
This example uses the interface RegressionFunction, the interface RegressionDerivativeFunction and the constructor Regression(double[][] xdata, double[] ydata, double[] weights), i.e. the second derivatives used in calculating the variance-covariance matrixare calculated analytically.
Compiling and running this application will;
• display a plot the experimental y values against the calculated values y for the best estimates of a and c;
• create a text file, RegressionOutputn.txt, listing the results of the regression.
Source file:
RegressionExampleThree.java

• The following example program, RegressionExampleFour, fits data to the functions
y0 = (a+x)2 + (b+x)2
y1 = (a+x)1.2 + (b+x)1.2
where the constants, a and b, are the unknown parameters whose best estimates are to be obtained by the regression, y is the dependent variable and x is the independent variable.
The test data was generated for values of a = 2.0 and b = 5.0 and white noise was added to the generated y values.
This example uses the interface RegressionFunction2 and the constructor Regression(double[] xdata, double[][] ydata).
Compiling and running this application will;
• display a plot the experimental y values against the calculated values y for the best estimates of a and c;
• create a text file, RegressionOutputn.txt, listing the results of the regression.
Source file: RegressionExampleFour.java

• The following example program, RegressionExampleFive, fits data to the functions
y0 = (a+x)2 + (b+x)2
y1 = (a+x)1.2 + (b+x)1.2
y2 = (a+x)0.9 + (b+x)0.9
where the constants, a and b, are the unknown parameters whose best estimates are to be obtained by the regression, y is the dependent variable and x is the independent variable.
The test data was generated for values of a = 2.0 and b = 5.0 and white noise was added to the generated y values.
This example uses the interface RegressionFunction2 and the constructor Regression(double[][] xdata, double[][] ydata).
Compiling and running this application will;
• display a plot the experimental y values against the calculated values y for the best estimates of a and c;
• create a text file, RegressionOutputn.txt, listing the results of the regression.
Source file: RegressionExampleFive.java

• The following example program, RegressionExampleSix, fits data to the function
y = (Ao.x)/(theta + x) + alpha
where the constants, Ao, theta and alpha, are the unknown parameters whose best estimates are to be obtained by the regression, y is the dependent variable and x is the independent variable.
The test data was generated for values of Ao = 2.3, theta = 4.0 and alpha = 0.1 and white noise was added to the generated y values.
The regression performed is a weighted non-linear regression in which the weights are calculated from experimental errors in both the dependent (y) variable values and the independent (x) variable values.
This example uses the interface RegressionFunction3 and the constructor Regression(double[] xdata, double[] ydata, double[] xerrors, double[] yerrors).
Compiling and running this application will;
• display a plot the experimental y values against the calculated values y for the best estimates of Ao, theta and alpha;
• create a text file, RegressionOutputn.txt, listing the results of the regression.
Source file: RegressionExampleSix.java

• The following example program, GaussianFit, illustrates the use of the Regression class in fitting examination marks to a Gaussian distribution.

Detailed description: GaussianFit
Source file: GaussianFit.java

### OTHER CLASSES USED BY THIS CLASS

This class uses the following classes in this library:
• Db
• ErrorProp
• Fmath
• FileOutput
• PlotGraph
• Plot (see PlotGraph documentation)
• Stat  Stat.betaFunction is called by class BetaFunction Stat.betaPDF is called by fitBeta Stat.chiSquareProb is called by getReducedChiSquarelinearPrintnonLinearPrint noParameters Stat.corrCoeff is called by generalLinearStatslinearPrintnonLinearPrint noParameters Stat.factorial is called by class PoissonFunction Stat.fTestProb is called by linearPrintnonLinearPrinttestOfAdditionalTerms_ArrayList Stat.gammaFunction is called by class GammaFunction Stat.gammaPDF is called by fitGamma fitErlang Stat.getCFmaxIter is called by getCFmaxIter Stat.getCFtolerance is called by getCFtolerance Stat.linearCorrCoeffProb is called by linearPrintnonLinearPrint noParameters Stat.logFactorial is called by fitPoisson Stat.mean is called by fitSigmoidThreshold fitsigmoidHillSips fitEC50 fitlogEC50 fitRectangularHyperbola fitStepFunction Stat.resetCFmaxIter is called by resetCFmaxIter Stat.resetCFtolerance is called by resetCFtolerance Stat.setStaticDenominatorToN is called by setDenominatorToN Stat.setStaticDenominatorToNminusOne is called by setDenominatorToNminusOne Stat.studentTcdf is called by generalLinearStatspseudoLinearStats

PERMISSION TO USE

Permission to use, copy and modify this software and its documentation for NON-COMMERCIAL purposes is granted, without fee, provided that an acknowledgement to the author, Dr Michael Thomas Flanagan at www.ee.ucl.ac.uk/~mflanaga, appears in all copies and associated documentation or publications.

Public listing of the source codes on the internet is not permitted.

Redistribution of the source codes or of the flanagan.jar file is not permitted.

Redistribution in binary form of all or parts of these classes is not permitted.

Dr Michael Thomas Flanagan makes no representations about the suitability or fitness of the software for any or for a particular purpose. Dr Michael Thomas Flanagan shall not be liable for any damages suffered as a result of using, modifying or distributing this software or its derivatives.

This page was prepared by Dr Michael Thomas Flanagan