Stat

Documentation of 'flanagan.analysis.Stat' Java class Stat

Skip navigation links

All Classes

Summary:
Nested |
Field |
Constr |
Method

Detail:
Field |
Constr |
Method

java.lang.Object
- flanagan.math.ArrayMaths
- - flanagan.analysis.Stat

```
public class Stat
extends ArrayMaths
```

Field Summary

Fields
Modifier and Type Field and Description

static double FPMIN
- Fields inherited from class flanagan.math.ArrayMaths
  sortedWords, words

Fields
Modifier and Type	Field and Description
`static double`	`FPMIN`

Constructor Summary

Constructors
Constructor and Description
`Stat()`
`Stat(java.util.ArrayList<java.lang.Object> xx)`
`Stat(java.math.BigDecimal[] xx)`
`Stat(java.math.BigInteger[] xx)`
`Stat(byte[] xx)`
`Stat(java.lang.Byte[] xx)`
`Stat(Complex[] xx)`
`Stat(double[] xx)`
`Stat(java.lang.Double[] xx)`
`Stat(float[] xx)`
`Stat(java.lang.Float[] xx)`
`Stat(int[] xx)`
`Stat(java.lang.Integer[] xx)`
`Stat(long[] xx)`
`Stat(java.lang.Long[] xx)`
`Stat(java.lang.Object[] xx)`
`Stat(Phasor[] xx)`
`Stat(short[] xx)`
`Stat(java.lang.Short[] xx)`
`Stat(java.lang.String[] xx)`
`Stat(java.util.Vector<java.lang.Object> xx)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static double`	`beta(double z, double w)`
`static double`	`betaCDF(double alpha, double beta, double limit)`
`static double`	`betaCDF(double min, double max, double alpha, double beta, double limit)`
`static double`	`betaFunction(double z, double w)`
`static double`	`betaMean(double alpha, double beta)`
`static double`	`betaMean(double min, double max, double alpha, double beta)`
`static double`	`betaMode(double alpha, double beta)`
`static double`	`betaMode(double min, double max, double alpha, double beta)`
`static double`	`betaPDF(double alpha, double beta, double x)`
`static double`	`betaPDF(double min, double max, double alpha, double beta, double x)`
`static double[]`	`betaRand(double min, double max, double alpha, double beta, int n)`
`static double[]`	`betaRand(double min, double max, double alpha, double beta, int n, long seed)`
`static double[]`	`betaRand(double alpha, double beta, int n)`
`static double[]`	`betaRand(double alpha, double beta, int n, long seed)`
`static double`	`betaStandardDeviation(double alpha, double beta)`
`static double`	`betaStandardDeviation(double min, double max, double alpha, double beta)`
`static double`	`betaStandDev(double alpha, double beta)`
`static double`	`betaStandDev(double min, double max, double alpha, double beta)`
`static double`	`binaryShannonEntropy(double p)`
`static double`	`binaryShannonEntropyBit(double p)`
`static double`	`binaryShannonEntropyDit(double p)`
`static double`	`binaryShannonEntropyNat(double p)`
`static double`	`binomial(double p, int n, int k)`
`static double`	`binomialCDF(double p, int n, int k)`
`static double`	`binomialCoeff(int n, int k)`
`static double`	`binomialPDF(double p, int n, int k)`
`static double`	`binomialProb(double p, int n, int k)`
`double[]`	`binomialRand(double prob, int nTrials, int n)`
`double[]`	`binomialRand(double prob, int nTrials, int n, long seed)`
`static double`	`chiSquare(double[] observed, double[] expected, double[] variance)`
`static double`	`chiSquareCDF(double chiSquare, int nu)`
`static double`	`chiSquareFreq(double[] observedFreq, double[] expectedFreq)`
`static double`	`chiSquareFreq(int[] observedFreq, int[] expectedFreq)`
`static double`	`chiSquareInverseCDF(int nu, double prob)`
`static double`	`chiSquareMean(int nu)`
`static double`	`chiSquareMode(int nu)`
`static double`	`chiSquarePDF(double chiSquare, int nu)`
`static double`	`chiSquareProb(double chiSquare, int nu)`
`static double[]`	`chiSquareRand(int nu, int n)`
`static double[]`	`chiSquareRand(int nu, int n, long seed)`
`static double`	`chiSquareStandardDeviation(int nu)`
`static double`	`chiSquareStandDev(int nu)`
`double`	`coefficientOfVariation()`
`static double`	`coefficientOfVariation(java.math.BigDecimal[] array)`
`static double`	`coefficientOfVariation(java.math.BigDecimal[] array, java.math.BigDecimal[] weight)`
`static double`	`coefficientOfVariation(java.math.BigInteger[] array)`
`static double`	`coefficientOfVariation(java.math.BigInteger[] array, java.math.BigInteger[] weight)`
`static double`	`coefficientOfVariation(double[] array)`
`static double`	`coefficientOfVariation(double[] array, double[] weight)`
`static float`	`coefficientOfVariation(float[] array)`
`static float`	`coefficientOfVariation(float[] array, float[] weight)`
`static double`	`complementaryRegularisedGammaFunction(double a, double x)`
`static double`	`complementaryRegularizedGammaFunction(double a, double x)`
`static double`	`contFract(double a, double b, double x)`
`void`	`convertBigWtoLittleW()`
`static double[]`	`convertBigWtoLittleW(java.math.BigDecimal[] bigW)`
`static double[]`	`convertBigWtoLittleW(java.math.BigInteger[] bigW)`
`static Complex[]`	`convertBigWtoLittleW(Complex[] bigW)`
`static double[]`	`convertBigWtoLittleW(double[] bigW)`
`static float[]`	`convertBigWtoLittleW(float[] bigW)`
`void`	`convertToHighest()`
`Stat`	`copy()`
`static double`	`corrCoeff(double[] xx, double[] yy)`
`static double`	`corrCoeff(double[] x, double[] y, double[] w)`
`static float`	`corrCoeff(float[] x, float[] y)`
`static double`	`corrCoeff(int[][] freqMatrix)`
`static double`	`corrCoeff(int[] x, int[] y)`
`static double`	`corrCoeff(int element00, int element01, int element10, int element11)`
`static double`	`corrCoeffPdf(double rCoeff, int nu)`
`static double`	`corrCoeffPDF(double rCoeff, int nu)`
`static double`	`corrCoeffProb(double rCoeff, int nu)`
`static double`	`covariance(double[] xx, double[] yy)`
`static double`	`covariance(double[] xx, double[] yy, double[] ww)`
`static float`	`covariance(float[] xx, float[] yy)`
`static double`	`covariance(int[] xx, int[] yy)`
`static double`	`covariance(long[] xx, long[] yy)`
`java.math.BigDecimal`	`curtosis_as_BigDecimal()`
`double`	`curtosis_as_double()`
`double`	`curtosis()`
`static java.math.BigDecimal`	`curtosis(java.math.BigDecimal[] aa)`
`static java.math.BigDecimal`	`curtosis(java.math.BigInteger[] aa)`
`static double`	`curtosis(double[] aa)`
`static float`	`curtosis(float[] aa)`
`static double`	`curtosis(int[] aa)`
`static double`	`curtosis(long[] aa)`
`java.math.BigDecimal`	`curtosisExcess_as_BigDecimal()`
`double`	`curtosisExcess_as_double()`
`double`	`curtosisExcess()`
`static java.math.BigDecimal`	`curtosisExcess(java.math.BigDecimal[] aa)`
`static java.math.BigDecimal`	`curtosisExcess(java.math.BigInteger[] aa)`
`static double`	`curtosisExcess(double[] aa)`
`static float`	`curtosisExcess(float[] aa)`
`static double`	`curtosisExcess(int[] aa)`
`static double`	`curtosisExcess(long[] aa)`
`java.math.BigDecimal`	`effectiveSampleNumber_as_BigDecimal()`
`Complex`	`effectiveSampleNumber_as_Complex()`
`double`	`effectiveSampleNumber_as_double()`
`double`	`effectiveSampleNumber()`
`static java.math.BigDecimal`	`effectiveSampleNumber(java.math.BigDecimal[] ww)`
`static java.math.BigDecimal`	`effectiveSampleNumber(java.math.BigInteger[] ww)`
`static Complex`	`effectiveSampleNumber(Complex[] ww)`
`static double`	`effectiveSampleNumber(double[] ww)`
`static float`	`effectiveSampleNumber(float[] ww)`
`static double`	`effectiveSampleNumberConjugateCalcn(Complex[] ww)`
`static double`	`engsetLoad(double blockingProbability, double totalResources, double numberOfSources)`
`static double`	`engsetLoad(double blockingProbability, int totalResources, int numberOfSources)`
`static double`	`engsetLoad(double blockingProbability, long totalResources, long numberOfSources)`
`static double`	`engsetProbability(double offeredTraffic, double totalResources, double numberOfSources)`
`static double`	`engsetProbability(double offeredTraffic, int totalResources, int numberOfSources)`
`static double`	`engsetProbability(double offeredTraffic, long totalResources, long numberOfSources)`
`static double[]`	`engsetResources(double blockingProbability, double offeredTraffic, double numberOfSources)`
`static double[]`	`engsetResources(double blockingProbability, double totalTraffic, int numberOfSources)`
`static double[]`	`engsetResources(double blockingProbability, double totalTraffic, long numberOfSources)`
`static double[]`	`engsetSources(double blockingProbability, double offeredTraffic, double resources)`
`static double[]`	`engsetSources(double blockingProbability, double totalTraffic, int resources)`
`static double[]`	`engsetSources(double blockingProbability, double totalTraffic, long resources)`
`static double`	`erf(double x)`
`static double`	`erfc(double x)`
`static double`	`erlangBload(double blockingProbability, double totalResources)`
`static double`	`erlangBload(double blockingProbability, int totalResources)`
`static double`	`erlangBload(double blockingProbability, long totalResources)`
`static double`	`erlangBprobability(double totalTraffic, double totalResources)`
`static double`	`erlangBprobability(double totalTraffic, int totalResources)`
`static double`	`erlangBprobability(double totalTraffic, long totalResources)`
`static double`	`erlangBprobabilityNIR(double totalTraffic, double totalResources)`
`static double`	`erlangBprobabilityNonIntRes(double totalTraffic, double totalResources)`
`static double[]`	`erlangBresources(double blockingProbability, double totalTraffic)`
`static double`	`erlangCDF(double lambda, double kay, double upperLimit)`
`static double`	`erlangCDF(double lambda, int kay, double upperLimit)`
`static double`	`erlangCDF(double lambda, long kay, double upperLimit)`
`static double`	`erlangCload(double nonZeroDelayProbability, double totalResources)`
`static double`	`erlangCload(double nonZeroDelayProbability, int totalResources)`
`static double`	`erlangCload(double nonZeroDelayProbability, long totalResources)`
`static double`	`erlangCprobability(double totalTraffic, double totalResources)`
`static double`	`erlangCprobability(double totalTraffic, int totalResources)`
`static double`	`erlangCprobability(double totalTraffic, long totalResources)`
`static double[]`	`erlangCresources(double nonZeroDelayProbability, double totalTraffic)`
`static double`	`erlangMean(double lambda, double kay)`
`static double`	`erlangMean(double lambda, int kay)`
`static double`	`erlangMean(double lambda, long kay)`
`static double`	`erlangMode(double lambda, double kay)`
`static double`	`erlangMode(double lambda, int kay)`
`static double`	`erlangMode(double lambda, long kay)`
`static double`	`erlangMprobability(double totalTraffic, double totalResources, double em)`
`static double`	`erlangMprobability(double totalTraffic, int totalResources, int em)`
`static double`	`erlangMprobability(double totalTraffic, long totalResources, long em)`
`static double`	`erlangPDF(double lambda, double kay, double x)`
`static double`	`erlangPDF(double lambda, int kay, double x)`
`static double`	`erlangPDF(double lambda, long kay, double x)`
`static double[]`	`erlangRand(double lambda, double kay, int n)`
`static double[]`	`erlangRand(double lambda, double kay, int n, long seed)`
`static double[]`	`erlangRand(double lambda, int kay, int n)`
`static double[]`	`erlangRand(double lambda, int kay, int n, long seed)`
`static double[]`	`erlangRand(double lambda, long kay, int n)`
`static double[]`	`erlangRand(double lambda, long kay, int n, long seed)`
`static double`	`erlangStandardDeviation(double lambda, double kay)`
`static double`	`erlangStandardDeviation(double lambda, int kay)`
`static double`	`erlangStandardDeviation(double lambda, long kay)`
`static double`	`erlangStandDev(double lambda, double kay)`
`static double`	`erlangStandDev(double lambda, int kay)`
`static double`	`erlangStandDev(double lambda, long kay)`
`java.math.BigDecimal`	`excessCurtosis_as_BigDecimal()`
`double`	`excessCurtosis_as_double()`
`double`	`excessCurtosis()`
`static java.math.BigDecimal`	`excessCurtosis(java.math.BigDecimal[] aa)`
`static java.math.BigDecimal`	`excessCurtosis(java.math.BigInteger[] aa)`
`static double`	`excessCurtosis(double[] aa)`
`static float`	`excessCurtosis(float[] aa)`
`static double`	`excessCurtosis(int[] aa)`
`static double`	`excessCurtosis(long[] aa)`
`java.math.BigDecimal`	`excessKurtosis_as_BigDecimal()`
`double`	`excessKurtosis_as_double()`
`double`	`excessKurtosis()`
`static java.math.BigDecimal`	`excessKurtosis(java.math.BigDecimal[] aa)`
`static java.math.BigDecimal`	`excessKurtosis(java.math.BigInteger[] aa)`
`static double`	`excessKurtosis(double[] aa)`
`static float`	`excessKurtosis(float[] aa)`
`static double`	`excessKurtosis(int[] aa)`
`static double`	`excessKurtosis(long[] aa)`
`static double`	`exponential(double mu, double sigma, double x)`
`static double`	`exponentialCDF(double mu, double sigma, double upperlimit)`
`static double`	`exponentialCDF(double mu, double sigma, double lowerlimit, double upperlimit)`
`static double`	`exponentialInverseCDF(double mu, double sigma, double prob)`
`static double`	`exponentialMean(double mu, double sigma)`
`static double`	`exponentialMedian(double mu, double sigma)`
`static double`	`exponentialMode(double mu)`
`static double[]`	`exponentialOrderStatisticMedians(double mu, double sigma, int n)`
`static double`	`exponentialPDF(double mu, double sigma, double x)`
`static double`	`exponentialProb(double mu, double sigma, double upperlimit)`
`static double`	`exponentialProb(double mu, double sigma, double lowerlimit, double upperlimit)`
`static double[]`	`exponentialRand(double mu, double sigma, int n)`
`static double[]`	`exponentialRand(double mu, double sigma, int n, long seed)`
`static double`	`exponentialStandardDeviation(double sigma)`
`static double`	`exponentialStandDev(double sigma)`
`static java.math.BigDecimal`	`factorial(java.math.BigDecimal n)`
`static java.math.BigInteger`	`factorial(java.math.BigInteger n)`
`static double`	`factorial(double n)`
`static int`	`factorial(int n)`
`static long`	`factorial(long n)`
`static double`	`fCompCDF(double var1, int df1, double var2, int df2)`
`static double`	`fCompCDF(double fValue, int df1, int df2)`
`static double`	`fDistributionInverseCDF(int nu1, int nu2, double prob)`
`static double[]`	`fDistributionOrderStatisticMedians(int nu1, int nu2, int n)`
`void`	`fitOneOrSeveralDistributions()`
`static void`	`fitOneOrSeveralDistributions(double[] array)`
`double`	`fPDF(double var1, int nu1, double var2, int nu2)`
`double`	`fPDF(double fValue, int nu1, int nu2)`
`static double[]`	`fRand(int nu1, int nu2, int n)`
`static double[]`	`fRand(int nu1, int nu2, int n, long seed)`
`static double`	`frechet(double mu, double sigma, double gamma, double x)`
`static double`	`frechetCDF(double mu, double sigma, double gamma, double lowerlimit, double upperlimit)`
`static double`	`frechetInverseCDF(double gamma, double prob)`
`static double`	`frechetInverseCDF(double sigma, double gamma, double prob)`
`static double`	`frechetInverseCDF(double mu, double sigma, double gamma, double prob)`
`static double`	`frechetMean(double mu, double sigma, double gamma)`
`static double`	`frechetMode(double mu, double sigma, double gamma)`
`static double[]`	`frechetOrderStatisticMedians(double mu, double sigma, double gamma, int n)`
`static double[]`	`frechetOrderStatisticMedians(double sigma, double gamma, int n)`
`static double[]`	`frechetOrderStatisticMedians(double gamma, int n)`
`static double`	`frechetPDF(double mu, double sigma, double gamma, double x)`
`static double`	`frechetProb(double mu, double sigma, double gamma, double upperlimit)`
`static double`	`frechetProb(double mu, double sigma, double gamma, double lowerlimit, double upperlimit)`
`static double[]`	`frechetRand(double mu, double sigma, double gamma, int n)`
`static double[]`	`frechetRand(double mu, double sigma, double gamma, int n, long seed)`
`static double`	`frechetStandardDeviation(double sigma, double gamma)`
`static double`	`frechetStandDev(double sigma, double gamma)`
`static double`	`fTestProb(double var1, int df1, double var2, int df2)`
`static double`	`fTestProb(double fValue, int df1, int df2)`
`static double`	`fTestValueGivenFprob(double fProb, int df1, int df2)`
`static double`	`gamma(double x)`
`static double`	`gammaCDF(double gamma, double upperLimit)`
`static double`	`gammaCDF(double mu, double beta, double gamma, double upperLimit)`
`static double`	`gammaFunction(double x)`
`static double[]`	`gammaFunctionMinimum()`
`static double`	`gammaMean(double mu, double beta, double gamma)`
`static double`	`gammaMode(double mu, double beta, double gamma)`
`static double`	`gammaPDF(double gamma, double x)`
`static double`	`gammaPDF(double mu, double beta, double gamma, double x)`
`static double[]`	`gammaRand(double mu, double beta, double gamma, int n)`
`static double[]`	`gammaRand(double mu, double beta, double gamma, int n, long seed)`
`static double`	`gammaStandardDeviation(double mu, double beta, double gamma)`
`static double`	`gammaStandDev(double mu, double beta, double gamma)`
`static double`	`gaussian(double mean, double sd, double x)`
`static double`	`gaussianCDF(double mean, double sd, double upperlimit)`
`static double`	`gaussianCDF(double mean, double sd, double lowerlimit, double upperlimit)`
`static double`	`gaussianInverseCDF(double prob)`
`static double`	`gaussianInverseCDF(double mean, double sd, double prob)`
`static double[]`	`gaussianOrderStatisticMedians(double mean, double sigma, int n)`
`static double[]`	`gaussianOrderStatisticMedians(int n)`
`static double`	`gaussianPDF(double mean, double sd, double x)`
`static double`	`gaussianProb(double mean, double sd, double upperlimit)`
`static double`	`gaussianProb(double mean, double sd, double lowerlimit, double upperlimit)`
`static double[]`	`gaussianRand(double mean, double sd, int n)`
`static double[]`	`gaussianRand(double mean, double sd, int n, long seed)`
`static double`	`generalisedEntropyOneNat(double[] p, double q, double r)`
`double`	`generalisedEntropyOneNat(double q, double r)`
`Complex`	`generalisedMean_as_Complex(Complex m)`
`Complex`	`generalisedMean_as_Complex(double m)`
`double`	`generalisedMean_as_double(java.math.BigDecimal m)`
`double`	`generalisedMean_as_double(double m)`
`double`	`generalisedMean(java.math.BigDecimal m)`
`static double`	`generalisedMean(java.math.BigDecimal[] aa, java.math.BigDecimal m)`
`static double`	`generalisedMean(java.math.BigDecimal[] aa, java.math.BigDecimal[] ww, java.math.BigDecimal m)`
`static double`	`generalisedMean(java.math.BigDecimal[] aa, java.math.BigDecimal[] ww, double m)`
`static double`	`generalisedMean(java.math.BigDecimal[] aa, double m)`
`static double`	`generalisedMean(java.math.BigInteger[] aa, java.math.BigInteger m)`
`static double`	`generalisedMean(java.math.BigInteger[] aa, java.math.BigInteger[] ww, java.math.BigInteger m)`
`static double`	`generalisedMean(java.math.BigInteger[] aa, java.math.BigInteger[] ww, double m)`
`static double`	`generalisedMean(java.math.BigInteger[] aa, double m)`
`static Complex`	`generalisedMean(Complex[] aa, Complex m)`
`static Complex`	`generalisedMean(Complex[] aa, Complex[] ww, Complex m)`
`static Complex`	`generalisedMean(Complex[] aa, Complex[] ww, double m)`
`static Complex`	`generalisedMean(Complex[] aa, double m)`
`double`	`generalisedMean(double m)`
`static double`	`generalisedMean(double[] aa, double m)`
`static double`	`generalisedMean(double[] aa, double[] ww, double m)`
`static float`	`generalisedMean(float[] aa, float m)`
`static float`	`generalisedMean(float[] aa, float[] ww, float m)`
`static double`	`generalizedEntropyOneNat(double[] p, double q, double r)`
`double`	`generalizedEntropyOneNat(double q, double r)`
`Complex`	`generalizedMean_as_Complex(Complex m)`
`Complex`	`generalizedMean_as_Complex(double m)`
`double`	`generalizedMean_as_double(java.math.BigDecimal m)`
`double`	`generalizedMean_as_double(double m)`
`double`	`generalizedMean(java.math.BigDecimal m)`
`static double`	`generalizedMean(java.math.BigDecimal[] aa, java.math.BigDecimal m)`
`static double`	`generalizedMean(java.math.BigDecimal[] aa, double m)`
`static double`	`generalizedMean(java.math.BigInteger[] aa, java.math.BigInteger m)`
`static double`	`generalizedMean(java.math.BigInteger[] aa, double m)`
`static Complex`	`generalizedMean(Complex[] aa, Complex m)`
`static Complex`	`generalizedMean(Complex[] aa, double m)`
`double`	`generalizedMean(double m)`
`static double`	`generalizedMean(double[] aa, double m)`
`static float`	`generalizedMean(float[] aa, float m)`
`Complex`	`geometricMean_as_Complex()`
`double`	`geometricMean_as_double()`
`double`	`geometricMean()`
`static double`	`geometricMean(java.math.BigDecimal[] aa)`
`static double`	`geometricMean(java.math.BigDecimal[] aa, java.math.BigDecimal[] ww)`
`static double`	`geometricMean(java.math.BigInteger[] aa)`
`static double`	`geometricMean(java.math.BigInteger[] aa, java.math.BigInteger[] ww)`
`static Complex`	`geometricMean(Complex[] aa)`
`static Complex`	`geometricMean(Complex[] aa, Complex[] ww)`
`static double`	`geometricMean(double[] aa)`
`static double`	`geometricMean(double[] aa, double[] ww)`
`static float`	`geometricMean(float[] aa)`
`static float`	`geometricMean(float[] aa, float[] ww)`
`static int`	`getCFmaxIter()`
`static double`	`getCFtolerance()`
`static double`	`getFpmin()`
`static int`	`getIncGammaMaxIter()`
`static double`	`getIncGammaTol()`
`static double[]`	`getLanczosCoeff()`
`static double`	`getLanczosGamma()`
`static int`	`getLanczosN()`
`static double`	`gumbelMax(double mu, double sigma, double x)`
`static double`	`gumbelMaxCDF(double mu, double sigma, double upperlimit)`
`static double`	`gumbelMaxCDF(double mu, double sigma, double lowerlimit, double upperlimit)`
`static double`	`gumbelMaxInverseCDF(double mu, double sigma, double prob)`
`static double`	`gumbelMaxMean(double mu, double sigma)`
`static double`	`gumbelMaxMedian(double mu, double sigma)`
`static double`	`gumbelMaxMode(double mu, double sigma)`
`static double[]`	`gumbelMaxOrderStatisticMedians(double mu, double sigma, int n)`
`static double`	`gumbelMaxPDF(double mu, double sigma, double x)`
`static double`	`gumbelMaxProb(double mu, double sigma, double upperlimit)`
`static double`	`gumbelMaxProb(double mu, double sigma, double lowerlimit, double upperlimit)`
`static double[]`	`gumbelMaxRand(double mu, double sigma, int n)`
`static double[]`	`gumbelMaxRand(double mu, double sigma, int n, long seed)`
`static double`	`gumbelMaxStandardDeviation(double sigma)`
`static double`	`gumbelMaxStandDev(double sigma)`
`static double`	`gumbelMin(double mu, double sigma, double x)`
`static double`	`gumbelMinCDF(double mu, double sigma, double lowerlimit, double upperlimit)`
`static double`	`gumbelMinInverseCDF(double mu, double sigma, double prob)`
`static double`	`gumbelMinMean(double mu, double sigma)`
`static double`	`gumbelMinMedian(double mu, double sigma)`
`static double`	`gumbelMinMode(double mu, double sigma)`
`static double[]`	`gumbelMinOrderStatisticMedians(double mu, double sigma, int n)`
`static double`	`gumbelMinPDF(double mu, double sigma, double x)`
`static double`	`gumbelMinProb(double mu, double sigma, double upperlimit)`
`static double`	`gumbelMinProb(double mu, double sigma, double lowerlimit, double upperlimit)`
`static double`	`gumbelMinProbCDF(double mu, double sigma, double upperlimit)`
`static double[]`	`gumbelMinRand(double mu, double sigma, int n)`
`static double[]`	`gumbelMinRand(double mu, double sigma, int n, long seed)`
`static double`	`gumbelMinStandardDeviation(double sigma)`
`static double`	`gumbelMinStandDev(double sigma)`
`java.math.BigDecimal`	`harmonicMean_as_BigDecimal()`
`Complex`	`harmonicMean_as_Complex()`
`double`	`harmonicMean_as_double()`
`double`	`harmonicMean()`
`static java.math.BigDecimal`	`harmonicMean(java.math.BigDecimal[] aa)`
`static java.math.BigDecimal`	`harmonicMean(java.math.BigDecimal[] aa, java.math.BigDecimal[] ww)`
`static java.math.BigDecimal`	`harmonicMean(java.math.BigInteger[] aa)`
`static java.math.BigDecimal`	`harmonicMean(java.math.BigInteger[] aa, java.math.BigInteger[] ww)`
`static Complex`	`harmonicMean(Complex[] aa)`
`static Complex`	`harmonicMean(Complex[] aa, Complex[] ww)`
`static double`	`harmonicMean(double[] aa)`
`static double`	`harmonicMean(double[] aa, double[] ww)`
`static float`	`harmonicMean(float[] aa)`
`static float`	`harmonicMean(float[] aa, float[] ww)`
`static double[][]`	`histogramBins(double[] data, double binWidth)`
`static double[][]`	`histogramBins(double[] data, double binWidth, double binZero)`
`static double[][]`	`histogramBins(double[] data, double binWidth, double binZero, double binUpper)`
`static double[][]`	`histogramBinsPlot(double[] data, double binWidth)`
`static double[][]`	`histogramBinsPlot(double[] data, double binWidth, double binZero)`
`static double[][]`	`histogramBinsPlot(double[] data, double binWidth, double binZero, double binUpper)`
`static double[][]`	`histogramBinsPlot(double[] data, double binWidth, double binZero, double binUpper, java.lang.String xLegend)`
`static double[][]`	`histogramBinsPlot(double[] data, double binWidth, double binZero, java.lang.String xLegend)`
`static double[][]`	`histogramBinsPlot(double[] data, double binWidth, java.lang.String xLegend)`
`static void`	`igSupress()`
`static double`	`incompleteBeta(double z, double w, double x)`
`static double`	`incompleteGamma(double a, double x)`
`static double`	`incompleteGammaComplementary(double a, double x)`
`static double`	`incompleteGammaFract(double a, double x)`
`static double`	`incompleteGammaSer(double a, double x)`
`java.math.BigDecimal`	`interQuartileMean_as_BigDecimal()`
`double`	`interQuartileMean_as_double()`
`double`	`interQuartileMean()`
`static java.math.BigDecimal`	`interQuartileMean(java.math.BigDecimal[] aa)`
`static java.math.BigDecimal`	`interQuartileMean(java.math.BigInteger[] aa)`
`static double`	`interQuartileMean(double[] aa)`
`static float`	`interQuartileMean(float[] aa)`
`static double`	`inverseChiSquareCDF(int nu, double prob)`
`static double`	`inverseExponentialCDF(double mu, double sigma, double prob)`
`static double[]`	`inverseGammaFunction(double gamma)`
`static double`	`inverseGaussianCDF(double prob)`
`static double`	`inverseGaussianCDF(double mean, double sd, double prob)`
`static double`	`inverseNormalCDF(double prob)`
`static double`	`inverseNormalCDF(double mean, double sd, double prob)`
`static double`	`inverseParetoCDF(double alpha, double beta, double prob)`
`static double`	`inverseRayleighCDF(double beta, double prob)`
`static double`	`inverseWeibullCDF(double gamma, double prob)`
`static double`	`inverseWeibullCDF(double sigma, double gamma, double prob)`
`static double`	`inverseWeibullCDF(double mu, double sigma, double gamma, double prob)`
`java.math.BigDecimal`	`kurtosis_as_BigDecimal()`
`double`	`kurtosis_as_double()`
`double`	`kurtosis()`
`static java.math.BigDecimal`	`kurtosis(java.math.BigDecimal[] aa)`
`static java.math.BigDecimal`	`kurtosis(java.math.BigInteger[] aa)`
`static double`	`kurtosis(double[] aa)`
`static float`	`kurtosis(float[] aa)`
`static double`	`kurtosis(int[] aa)`
`static double`	`kurtosis(long[] aa)`
`java.math.BigDecimal`	`kurtosisExcess_as_BigDecimal()`
`double`	`kurtosisExcess_as_double()`
`double`	`kurtosisExcess()`
`static java.math.BigDecimal`	`kurtosisExcess(java.math.BigDecimal[] aa)`
`static java.math.BigDecimal`	`kurtosisExcess(java.math.BigInteger[] aa)`
`static double`	`kurtosisExcess(double[] aa)`
`static float`	`kurtosisExcess(float[] aa)`
`static double`	`kurtosisExcess(int[] aa)`
`static double`	`kurtosisExcess(long[] aa)`
`static double`	`linearCorrCoeff(double rCoeff, int nu)`
`static double`	`linearCorrCoeffProb(double rCoeff, int nu)`
`static double`	`logFactorial(double n)`
`static double`	`logFactorial(int n)`
`static double`	`logFactorial(long n)`
`static double`	`logGamma(double x)`
`static double`	`logGammaFunction(double x)`
`static double`	`logistic(double mu, double beta, double x)`
`static double`	`logisticCDF(double mu, double beta, double upperlimit)`
`static double`	`logisticCDF(double mu, double beta, double lowerlimit, double upperlimit)`
`static double`	`logisticInverseCDF(double mu, double beta, double prob)`
`static double`	`logisticMean(double mu)`
`static double`	`logisticMedian(double mu)`
`static double`	`logisticMode(double mu)`
`static double[]`	`logisticOrderStatisticMedians(double mu, double beta, int n)`
`static double`	`logisticPDF(double mu, double beta, double x)`
`static double`	`logisticProb(double mu, double beta, double upperlimit)`
`static double`	`logisticProb(double mu, double beta, double lowerlimit, double upperlimit)`
`static double[]`	`logisticRand(double mu, double beta, int n)`
`static double[]`	`logisticRand(double mu, double beta, int n, long seed)`
`static double`	`logisticStandardDeviation(double beta)`
`static double`	`logisticStandDev(double beta)`
`static double`	`logisticTwoParCDF(double mu, double beta, double upperlimit)`
`static double`	`logisticTwoParCDF(double mu, double beta, double lowerlimit, double upperlimit)`
`static double`	`logisticTwoParInverseCDF(double mu, double beta, double prob)`
`static double`	`logisticTwoParMean(double mu)`
`static double`	`logisticTwoParMedian(double mu)`
`static double`	`logisticTwoParMode(double mu)`
`static double[]`	`logisticTwoParOrderStatisticMedians(double mu, double beta, int n)`
`static double`	`logisticTwoParPDF(double mu, double beta, double x)`
`static double[]`	`logisticTwoParRand(double mu, double beta, int n)`
`static double[]`	`logisticTwoParRand(double mu, double beta, int n, long seed)`
`static double`	`logisticTwoParStandardDeviation(double beta)`
`static double`	`logNormalCDF(double mu, double sigma, double upperLimit)`
`static double`	`logNormalCDF(double mu, double sigma, double lowerLimit, double upperLimit)`
`static double`	`logNormalInverseCDF(double mu, double sigma, double prob)`
`static double`	`logNormalInverseCDF(double alpha, double beta, double gamma, double prob)`
`static double`	`logNormalMean(double mu, double sigma)`
`static double`	`logNormalMedian(double mu)`
`static double`	`logNormalMode(double mu, double sigma)`
`static double[]`	`logNormalOrderStatisticMedians(double alpha, double beta, double gamma, int n)`
`static double[]`	`logNormalOrderStatisticMedians(double mu, double sigma, int n)`
`static double`	`logNormalPDF(double mu, double sigma, double x)`
`static double[]`	`logNormalRand(double mu, double sigma, int n)`
`static double[]`	`logNormalRand(double mu, double sigma, int n, long seed)`
`static double`	`logNormalStandardDeviation(double mu, double sigma)`
`static double`	`logNormalStandDev(double mu, double sigma)`
`static double`	`logNormalThreeParCDF(double alpha, double beta, double gamma, double upperLimit)`
`static double`	`logNormalThreeParCDF(double alpha, double beta, double gamma, double lowerLimit, double upperLimit)`
`static double`	`logNormalThreeParInverseCDF(double alpha, double beta, double gamma, double prob)`
`static double`	`logNormalThreeParMean(double alpha, double beta, double gamma)`
`static double`	`logNormalThreeParMedian(double alpha, double gamma)`
`static double`	`logNormalThreeParMode(double alpha, double beta, double gamma)`
`static double[]`	`logNormalThreeParOrderStatisticMedians(double alpha, double beta, double gamma, int n)`
`static double`	`logNormalThreeParPDF(double alpha, double beta, double gamma, double x)`
`static double[]`	`logNormalThreeParRand(double alpha, double beta, double gamma, int n)`
`static double[]`	`logNormalThreeParRand(double alpha, double beta, double gamma, int n, long seed)`
`static double`	`logNormalThreeParStandardDeviation(double alpha, double beta, double gamma)`
`static double`	`logNormalThreeParStandDev(double alpha, double beta, double gamma)`
`static double`	`logNormalTwoParCDF(double mu, double sigma, double upperLimit)`
`static double`	`logNormalTwoParCDF(double mu, double sigma, double lowerLimit, double upperLimit)`
`static double`	`logNormaltwoParInverseCDF(double mu, double sigma, double prob)`
`static double`	`logNormalTwoParMean(double mu, double sigma)`
`static double`	`logNormalTwoParMedian(double mu)`
`static double`	`logNormalTwoParMode(double mu, double sigma)`
`static double[]`	`logNormalTwoParOrderStatisticMedians(double mu, double sigma, int n)`
`static double`	`logNormalTwoParPDF(double mu, double sigma, double x)`
`static double[]`	`logNormalTwoParRand(double mu, double sigma, int n)`
`static double[]`	`logNormalTwoParRand(double mu, double sigma, int n, long seed)`
`static double`	`logNormalTwoParStandardDeviation(double mu, double sigma)`
`static double`	`logNormalTwoParStandDev(double mu, double sigma)`
`static double`	`lorentzian(double mu, double gamma, double x)`
`static double`	`lorentzianCDF(double mu, double gamma, double lowerlimit, double upperlimit)`
`static double`	`lorentzianInverseCDF(double mu, double gamma, double prob)`
`static double[]`	`lorentzianOrderStatisticMedians(double mu, double gamma, int n)`
`static double`	`lorentzianPDF(double mu, double gamma, double x)`
`static double`	`lorentzianProb(double mu, double gamma, double upperlimit)`
`static double`	`lorentzianProb(double mu, double gamma, double lowerlimit, double upperlimit)`
`static double[]`	`lorentzianRand(double mu, double gamma, int n)`
`static double[]`	`lorentzianRand(double mu, double gamma, int n, long seed)`
`java.util.ArrayList<java.lang.Object>`	`lowerOutliersAnscombe_as_BigDecimal(java.math.BigDecimal constant)`
`java.util.ArrayList<java.lang.Object>`	`lowerOutliersAnscombe_as_BigDecimal(java.math.BigInteger constant)`
`java.util.ArrayList<java.lang.Object>`	`lowerOutliersAnscombe_as_double(double constant)`
`java.util.ArrayList<java.lang.Object>`	`lowerOutliersAnscombe(java.math.BigDecimal constant)`
`static java.util.Vector<java.lang.Object>`	`lowerOutliersAnscombe(java.math.BigDecimal[] values, java.math.BigDecimal constant)`
`java.util.ArrayList<java.lang.Object>`	`lowerOutliersAnscombe(java.math.BigInteger constant)`
`static java.util.Vector<java.lang.Object>`	`lowerOutliersAnscombe(java.math.BigInteger[] values, java.math.BigInteger constant)`
`java.util.ArrayList<java.lang.Object>`	`lowerOutliersAnscombe(double constant)`
`static java.util.Vector<java.lang.Object>`	`lowerOutliersAnscombe(double[] values, double constant)`
`static java.util.ArrayList<java.lang.Object>`	`lowerOutliersAnscombeAsArrayList(java.math.BigDecimal[] values, java.math.BigDecimal constant)`
`static java.util.ArrayList<java.lang.Object>`	`lowerOutliersAnscombeAsArrayList(java.math.BigInteger[] values, java.math.BigInteger constant)`
`static java.util.ArrayList<java.lang.Object>`	`lowerOutliersAnscombeAsArrayList(double[] values, double constant)`
`static java.util.Vector<java.lang.Object>`	`lowerOutliersAnscombeAsVector(java.math.BigDecimal[] values, java.math.BigDecimal constant)`
`static java.util.Vector<java.lang.Object>`	`lowerOutliersAnscombeAsVector(java.math.BigInteger[] values, java.math.BigInteger constant)`
`static java.util.Vector<java.lang.Object>`	`lowerOutliersAnscombeAsVector(double[] values, double constant)`
`java.math.BigDecimal`	`mean_as_BigDecimal()`
`Complex`	`mean_as_Complex()`
`double`	`mean_as_double()`
`double`	`mean()`
`static java.math.BigDecimal`	`mean(java.math.BigDecimal[] aa)`
`static java.math.BigDecimal`	`mean(java.math.BigDecimal[] aa, java.math.BigDecimal[] ww)`
`static java.math.BigDecimal`	`mean(java.math.BigInteger[] aa)`
`static java.math.BigDecimal`	`mean(java.math.BigInteger[] aa, java.math.BigInteger[] ww)`
`static double`	`mean(byte[] aa)`
`static Complex`	`mean(Complex[] aa)`
`static Complex`	`mean(Complex[] aa, Complex[] ww)`
`static double`	`mean(double[] aa)`
`static double`	`mean(double[] aa, double[] ww)`
`static float`	`mean(float[] aa)`
`static float`	`mean(float[] aa, float[] ww)`
`static double`	`mean(int[] aa)`
`static double`	`mean(long[] aa)`
`static double`	`mean(short[] aa)`
`double[]`	`meanConfidenceLimits(double prob)`
`static double[]`	`meanConfidenceLimits(double mean, double sd, double prob)`
`java.math.BigDecimal`	`median_as_BigDecimal()`
`double`	`median_as_double()`
`double`	`median()`
`static java.math.BigDecimal`	`median(java.math.BigDecimal[] aa)`
`static java.math.BigInteger`	`median(java.math.BigInteger[] aa)`
`static double`	`median(double[] aa)`
`static float`	`median(float[] aa)`
`static double`	`median(int[] aa)`
`static double`	`median(long[] aa)`
`double`	`medianSkewness_as_double()`
`double`	`medianSkewness()`
`static double`	`medianSkewness(java.math.BigDecimal[] aa)`
`static double`	`medianSkewness(double[] aa)`
`static float`	`medianSkewness(float[] aa)`
`static double`	`medianSkewness(int[] aa)`
`static double`	`medianSkewness(long[] aa)`
`double`	`momentSkewness_as_double()`
`double`	`momentSkewness()`
`static double`	`momentSkewness(java.math.BigDecimal[] aa)`
`static double`	`momentSkewness(double[] aa)`
`static float`	`momentSkewness(float[] aa)`
`static double`	`momentSkewness(int[] aa)`
`static double`	`momentSkewness(long[] aa)`
`static double`	`normal(double mean, double sd, double x)`
`static double`	`normalCDF(double mean, double sd, double upperlimit)`
`static double`	`normalCDF(double mean, double sd, double lowerlimit, double upperlimit)`
`static double`	`normalInverseCDF(double prob)`
`static double`	`normalInverseCDF(double mean, double sd, double prob)`
`static double[]`	`normalOrderStatisticMedians(double mean, double sigma, int n)`
`static double[]`	`normalOrderStatisticMedians(int n)`
`static double`	`normalPDF(double mean, double sd, double x)`
`static double`	`normalProb(double mean, double sd, double upperlimit)`
`static double`	`normalProb(double mean, double sd, double lowerlimit, double upperlimit)`
`static double[]`	`normalRand(double mean, double sd, int n)`
`static double[]`	`normalRand(double mean, double sd, int n, long seed)`
`static double`	`pareto(double alpha, double beta, double x)`
`static double`	`paretoCDF(double alpha, double beta, double upperlimit)`
`static double`	`paretoCDF(double alpha, double beta, double lowerlimit, double upperlimit)`
`static double`	`paretoInverseCDF(double alpha, double beta, double prob)`
`static double`	`paretoMean(double alpha, double beta)`
`static double`	`paretoMode(double beta)`
`static double[]`	`paretoOrderStatisticMedians(double alpha, double beta, int n)`
`static double`	`paretoPDF(double alpha, double beta, double x)`
`static double`	`paretoProb(double alpha, double beta, double upperlimit)`
`static double`	`paretoProb(double alpha, double beta, double lowerlimit, double upperlimit)`
`static double[]`	`paretoRand(double alpha, double beta, int n)`
`static double[]`	`paretoRand(double alpha, double beta, int n, long seed)`
`static double`	`paretoStandardDeviation(double alpha, double beta)`
`static double`	`paretoStandDev(double alpha, double beta)`
`static double`	`poisson(int k, double mean)`
`static double`	`poissonCDF(int k, double mean)`
`static double`	`poissonPDF(int k, double mean)`
`static double`	`poissonProb(int k, double mean)`
`static double[]`	`poissonRand(double mean, int n)`
`static double[]`	`poissonRand(double mean, int n, long seed)`
`static double`	`probAtn(double tValue, int df)`
`static double`	`pValue(double tValue, int df)`
`java.math.BigDecimal`	`quartileSkewness_as_BigDecimal()`
`double`	`quartileSkewness_as_double()`
`double`	`quartileSkewness()`
`static java.math.BigDecimal`	`quartileSkewness(java.math.BigDecimal[] aa)`
`static java.math.BigDecimal`	`quartileSkewness(java.math.BigInteger[] aa)`
`static double`	`quartileSkewness(double[] aa)`
`static float`	`quartileSkewness(float[] aa)`
`static double`	`quartileSkewness(int[] aa)`
`static double`	`quartileSkewness(long[] aa)`
`static double`	`rayleigh(double beta, double x)`
`static double`	`rayleighCDF(double beta, double upperlimit)`
`static double`	`rayleighCDF(double beta, double lowerlimit, double upperlimit)`
`static double`	`rayleighInverseCDF(double beta, double prob)`
`static double`	`rayleighMean(double beta)`
`static double`	`rayleighMedian(double beta)`
`static double`	`rayleighMode(double beta)`
`static double[]`	`rayleighOrderStatisticMedians(double beta, int n)`
`static double`	`rayleighPDF(double beta, double x)`
`static double`	`rayleighProb(double beta, double upperlimit)`
`static double`	`rayleighProb(double beta, double lowerlimit, double upperlimit)`
`static double[]`	`rayleighRand(double beta, int n)`
`static double[]`	`rayleighRand(double beta, int n, long seed)`
`static double`	`rayleighStandardDeviation(double beta)`
`static double`	`rayleighStandDev(double beta)`
`static double`	`regIncompleteGamma(double a, double x)`
`static double`	`regIncompleteGammaComplementary(double a, double x)`
`static double`	`regularisedBetaFunction(double z, double w, double x)`
`static double`	`regularisedGammaFunction(double a, double x)`
`static double`	`regularizedBetaFunction(double z, double w, double x)`
`static double`	`regularizedGammaFunction(double a, double x)`
`double`	`renyiEntropy(double alpha)`
`static double`	`renyiEntropy(double[] p, double alpha)`
`double`	`renyiEntropyBit(double alpha)`
`static double`	`renyiEntropyBit(double[] p, double alpha)`
`double`	`renyiEntropyDit(double alpha)`
`static double`	`renyiEntropyDit(double[] p, double alpha)`
`double`	`renyiEntropyNat(double alpha)`
`static double`	`renyiEntropyNat(double[] p, double alpha)`
`static void`	`resetCFmaxIter(int cfMaxIter)`
`static void`	`resetCFtolerance(double cfTol)`
`double`	`rms()`
`static double`	`rms(java.math.BigDecimal[] aa)`
`static double`	`rms(java.math.BigDecimal[] aa, java.math.BigDecimal[] ww)`
`static double`	`rms(java.math.BigInteger[] aa)`
`static double`	`rms(java.math.BigInteger[] aa, java.math.BigInteger[] ww)`
`static double`	`rms(double[] aa)`
`static double`	`rms(double[] aa, double[] ww)`
`static float`	`rms(float[] aa)`
`static float`	`rms(float[] aa, float[] ww)`
`static double[]`	`scale(java.math.BigDecimal[] aa, double mean, double sd)`
`static double[]`	`scale(java.math.BigInteger[] aa, double mean, double sd)`
`static double[]`	`scale(double[] aa, double mean, double sd)`
`double[]`	`scale(double mean, double sd)`
`static float[]`	`scale(float[] aa, float mean, float sd)`
`static double[]`	`scale(int[] aa, double mean, double sd)`
`static double[]`	`scale(long[] aa, double mean, double sd)`
`static java.math.BigDecimal`	`secondQuartile(java.math.BigDecimal[] aa)`
`static java.math.BigInteger`	`secondQuartile(java.math.BigInteger[] aa)`
`static double`	`secondQuartile(double[] aa)`
`static float`	`secondQuartile(float[] aa)`
`static double`	`secondQuartile(int[] aa)`
`static double`	`secondQuartile(long[] aa)`
`void`	`setDenominatorToN()`
`void`	`setDenominatorToNminusOne()`
`static void`	`setIncGammaMaxIter(int igfiter)`
`static void`	`setIncGammaTol(double igfeps)`
`static void`	`setStaticDenominatorToN()`
`static void`	`setStaticDenominatorToNminusOne()`
`static void`	`setStaticWeightsToBigW()`
`static void`	`setStaticWeightsToLittleW()`
`void`	`setWeights(java.util.ArrayList<java.lang.Object> xx)`
`void`	`setWeights(java.math.BigDecimal[] xx)`
`void`	`setWeights(java.math.BigInteger[] xx)`
`void`	`setWeights(byte[] xx)`
`void`	`setWeights(java.lang.Byte[] xx)`
`void`	`setWeights(Complex[] xx)`
`void`	`setWeights(double[] xx)`
`void`	`setWeights(java.lang.Double[] xx)`
`void`	`setWeights(float[] xx)`
`void`	`setWeights(java.lang.Float[] xx)`
`void`	`setWeights(int[] xx)`
`void`	`setWeights(java.lang.Integer[] xx)`
`void`	`setWeights(long[] xx)`
`void`	`setWeights(java.lang.Long[] xx)`
`void`	`setWeights(java.lang.Object[] xx)`
`void`	`setWeights(Phasor[] xx)`
`void`	`setWeights(short[] xx)`
`void`	`setWeights(java.lang.Short[] xx)`
`void`	`setWeights(java.util.Vector<java.lang.Object> xx)`
`void`	`setWeightsToBigW()`
`void`	`setWeightsToLittleW()`
`double`	`shannonEntropy()`
`static double`	`shannonEntropy(double[] p)`
`double`	`shannonEntropyBit()`
`static double`	`shannonEntropyBit(double[] p)`
`double`	`shannonEntropyDit()`
`static double`	`shannonEntropyDit(double[] p)`
`double`	`shannonEntropyNat()`
`static double`	`shannonEntropyNat(double[] p)`
`double`	`standardDeviation_as_Complex_ConjugateCalcn()`
`Complex`	`standardDeviation_as_Complex()`
`double`	`standardDeviation_as_double()`
`double`	`standardDeviation_of_ComplexImaginaryParts()`
`double`	`standardDeviation_of_ComplexModuli()`
`double`	`standardDeviation_of_ComplexRealParts()`
`double`	`standardDeviation()`
`static double`	`standardDeviation(java.math.BigDecimal[] aa)`
`static double`	`standardDeviation(java.math.BigDecimal[] aa, java.math.BigDecimal[] ww)`
`static double`	`standardDeviation(java.math.BigInteger[] aa)`
`static double`	`standardDeviation(java.math.BigInteger[] aa, java.math.BigInteger[] ww)`
`static Complex`	`standardDeviation(Complex[] aa)`
`static Complex`	`standardDeviation(Complex[] aa, Complex[] ww)`
`static double`	`standardDeviation(double[] aa)`
`static double`	`standardDeviation(double[] aa, double[] ww)`
`static float`	`standardDeviation(float[] aa)`
`static float`	`standardDeviation(float[] aa, float[] ww)`
`static double`	`standardDeviation(int[] aa)`
`static double`	`standardDeviation(long[] aa)`
`static double`	`standardDeviationConjugateCalcn(Complex[] aa)`
`static double`	`standardDeviationConjugateCalcn(Complex[] aa, Complex[] ww)`
`static double`	`standardDeviationImaginaryParts(Complex[] aa)`
`static double`	`standardDeviationImaginaryParts(Complex[] aa, Complex[] ww)`
`static double`	`standardDeviationModuli(Complex[] aa)`
`static double`	`standardDeviationModuli(Complex[] aa, Complex[] ww)`
`static double`	`standardDeviationRealParts(Complex[] aa)`
`static double`	`standardDeviationRealParts(Complex[] aa, Complex[] ww)`
`double`	`standardError_as_Complex_ConjugateCalcn()`
`Complex`	`standardError_as_Complex()`
`double`	`standardError_as_double()`
`double`	`standardError_of_ComplexImaginaryParts()`
`double`	`standardError_of_ComplexModuli()`
`double`	`standardError_of_ComplexRealParts()`
`double`	`standardError()`
`static double`	`standardError(java.math.BigDecimal[] aa)`
`static double`	`standardError(java.math.BigDecimal[] aa, java.math.BigDecimal[] ww)`
`static double`	`standardError(java.math.BigInteger[] aa)`
`static double`	`standardError(java.math.BigInteger[] aa, java.math.BigInteger[] ww)`
`static Complex`	`standardError(Complex[] aa)`
`static Complex`	`standardError(Complex[] aa, Complex[] ww)`
`static double`	`standardError(double[] aa)`
`static double`	`standardError(double[] aa, double[] ww)`
`static float`	`standardError(float[] aa)`
`static float`	`standardError(float[] aa, float[] ww)`
`static double`	`standardError(int[] aa)`
`static double`	`standardError(long[] aa)`
`static double`	`standardErrorConjugateCalcn(Complex[] aa)`
`static double`	`standardErrorConjugateCalcn(Complex[] aa, Complex[] ww)`
`static double`	`standardErrorImaginaryParts(Complex[] aa)`
`static double`	`standardErrorImaginaryParts(Complex[] aa, Complex[] ww)`
`static double`	`standardErrorModuli(Complex[] aa)`
`static double`	`standardErrorModuli(Complex[] aa, Complex[] ww)`
`static double`	`standardErrorRealParts(Complex[] aa)`
`static double`	`standardErrorRealParts(Complex[] aa, Complex[] ww)`
`double[]`	`standardise()`
`static double[]`	`standardise(java.math.BigDecimal[] aa)`
`static double[]`	`standardise(java.math.BigInteger[] aa)`
`static double[]`	`standardise(double[] aa)`
`static float[]`	`standardise(float[] aa)`
`static double[]`	`standardise(int[] aa)`
`static double[]`	`standardise(long[] aa)`
`double[]`	`standardize()`
`static double[]`	`standardize(java.math.BigDecimal[] aa)`
`static double[]`	`standardize(java.math.BigInteger[] aa)`
`static double[]`	`standardize(double[] aa)`
`static float[]`	`standardize(float[] aa)`
`static double[]`	`standardize(int[] aa)`
`static double[]`	`standardize(long[] aa)`
`static double`	`studentst(double tValue, int df)`
`static double`	`studentstCDF(double tValue, int df)`
`static double`	`studentstMean(int df)`
`static double`	`studentstMedian()`
`static double`	`studentstMode()`
`static double`	`studentstPDF(double tValue, int df)`
`static double[]`	`studentstRand(int nu, int n)`
`static double[]`	`studentstRand(int nu, int n, long seed)`
`static double`	`studentstStandardDeviation(int df)`
`static double`	`studentT(double tValue, int df)`
`static double`	`studentTcdf(double tValueLower, double tValueUpper, int df)`
`static double`	`studentTcdf(double tValue, int df)`
`static double`	`studentTCDF(double tValue, int df)`
`static double`	`studentTmean(int df)`
`static double`	`studentTmedian()`
`static double`	`studentTmode()`
`static double`	`studentTpdf(double tValue, int df)`
`static double`	`studentTPDF(double tValue, int df)`
`static double`	`studentTProb(double tValue, int df)`
`static double[]`	`studentTrand(int nu, int n)`
`static double[]`	`studentTRand(int nu, int n)`
`static double[]`	`studentTrand(int nu, int n, long seed)`
`static double[]`	`studentTRand(int nu, int n, long seed)`
`static double`	`studentTstandDev(int df)`
`java.math.BigDecimal[]`	`subtractMean_as_BigDecimal()`
`Complex[]`	`subtractMean_as_Complex()`
`double[]`	`subtractMean_as_double()`
`double[]`	`subtractMean()`
`static java.math.BigDecimal[]`	`subtractMean(java.math.BigDecimal[] array)`
`static java.math.BigDecimal[]`	`subtractMean(java.math.BigDecimal[] array, java.math.BigDecimal[] weights)`
`static java.math.BigDecimal[]`	`subtractMean(java.math.BigInteger[] array)`
`static java.math.BigDecimal[]`	`subtractMean(java.math.BigInteger[] array, java.math.BigInteger[] weights)`
`static Complex[]`	`subtractMean(Complex[] array)`
`static Complex[]`	`subtractMean(Complex[] array, Complex[] weights)`
`static double[]`	`subtractMean(double[] array)`
`static double[]`	`subtractMean(double[] array, double[] weights)`
`static float[]`	`subtractMean(float[] array)`
`static float[]`	`subtractMean(float[] array, float[] weights)`
`java.math.BigDecimal[]`	`subtractWeightedMean_as_BigDecimal()`
`Complex[]`	`subtractWeightedMean_as_Complex()`
`double[]`	`subtractWeightedMean_as_double()`
`double[]`	`subtractWeightedMean()`
`java.math.BigDecimal`	`trueSampleNumber_as_BigDecimal()`
`Complex`	`trueSampleNumber_as_Complex()`
`double`	`trueSampleNumber_as_double()`
`int`	`trueSampleNumber_as_int()`
`int`	`trueSampleNumber()`
`double`	`tsallisEntropyNat(double q)`
`static double`	`tsallisEntropyNat(double[] p, double q)`
`static double[]`	`uniformOrderStatisticMedians(int n)`
`java.util.ArrayList<java.lang.Object>`	`upperOutliersAnscombe_as_BigDecimal(java.math.BigDecimal constant)`
`java.util.ArrayList<java.lang.Object>`	`upperOutliersAnscombe_as_BigDecimal(java.math.BigInteger constant)`
`java.util.ArrayList<java.lang.Object>`	`upperOutliersAnscombe_as_double(double constant)`
`java.util.ArrayList<java.lang.Object>`	`upperOutliersAnscombe(java.math.BigDecimal constant)`
`static java.util.Vector<java.lang.Object>`	`upperOutliersAnscombe(java.math.BigDecimal[] values, java.math.BigDecimal constant)`
`java.util.ArrayList<java.lang.Object>`	`upperOutliersAnscombe(java.math.BigInteger constant)`
`static java.util.Vector<java.lang.Object>`	`upperOutliersAnscombe(java.math.BigInteger[] values, java.math.BigInteger constant)`
`java.util.ArrayList<java.lang.Object>`	`upperOutliersAnscombe(double constant)`
`static java.util.Vector<java.lang.Object>`	`upperOutliersAnscombe(double[] values, double constant)`
`static java.util.ArrayList<java.lang.Object>`	`upperOutliersAnscombeAsArrayList(java.math.BigDecimal[] values, java.math.BigDecimal constant)`
`static java.util.ArrayList<java.lang.Object>`	`upperOutliersAnscombeAsArrayList(java.math.BigInteger[] values, java.math.BigInteger constant)`
`static java.util.ArrayList<java.lang.Object>`	`upperOutliersAnscombeAsArrayList(double[] values, double constant)`
`static java.util.Vector<java.lang.Object>`	`upperOutliersAnscombeAsVector(java.math.BigDecimal[] values, java.math.BigDecimal constant)`
`static java.util.Vector<java.lang.Object>`	`upperOutliersAnscombeAsVector(java.math.BigInteger[] values, java.math.BigInteger constant)`
`static java.util.Vector<java.lang.Object>`	`upperOutliersAnscombeAsVector(double[] values, double constant)`
`void`	`useEffectiveN()`
`static void`	`useStaticEffectiveN()`
`static void`	`useStaticTrueN()`
`void`	`useTrueN()`
`java.math.BigDecimal`	`variance_as_BigDecimal()`
`double`	`variance_as_Complex_ConjugateCalcn()`
`Complex`	`variance_as_Complex()`
`double`	`variance_as_double()`
`double`	`variance_of_ComplexImaginaryParts()`
`double`	`variance_of_ComplexModuli()`
`double`	`variance_of_ComplexRealParts()`
`double`	`variance()`
`static java.math.BigDecimal`	`variance(java.math.BigDecimal[] aa)`
`static java.math.BigDecimal`	`variance(java.math.BigDecimal[] aa, java.math.BigDecimal[] ww)`
`static java.math.BigDecimal`	`variance(java.math.BigInteger[] aa)`
`static java.math.BigDecimal`	`variance(java.math.BigInteger[] aa, java.math.BigInteger[] ww)`
`static Complex`	`variance(Complex[] aa)`
`static Complex`	`variance(Complex[] aa, Complex[] ww)`
`static double`	`variance(double[] aa)`
`static double`	`variance(double[] aa, double[] ww)`
`static float`	`variance(float[] aa)`
`static float`	`variance(float[] aa, float[] ww)`
`static double`	`variance(int[] aa)`
`static double`	`variance(long[] aa)`
`static double`	`varianceConjugateCalcn(Complex[] aa)`
`static double`	`varianceConjugateCalcn(Complex[] aa, Complex[] ww)`
`static double`	`varianceImaginaryParts(Complex[] aa)`
`static double`	`varianceImaginaryParts(Complex[] aa, Complex[] ww)`
`static double`	`varianceModuli(Complex[] aa)`
`static double`	`varianceModuli(Complex[] aa, Complex[] ww)`
`static double`	`varianceRealParts(Complex[] aa)`
`static double`	`varianceRealParts(Complex[] aa, Complex[] ww)`
`double`	`volatilityLogChange()`
`static double`	`volatilityLogChange(java.math.BigDecimal[] array)`
`static double`	`volatilityLogChange(java.math.BigInteger[] array)`
`static double`	`volatilityLogChange(double[] array)`
`static float`	`volatilityLogChange(float[] array)`
`double`	`volatilityPerCentChange()`
`static double`	`volatilityPerCentChange(java.math.BigDecimal[] array)`
`static double`	`volatilityPerCentChange(java.math.BigInteger[] array)`
`static double`	`volatilityPerCentChange(double[] array)`
`static double`	`volatilityPerCentChange(float[] array)`
`static double`	`weibull(double mu, double sigma, double gamma, double x)`
`static double`	`weibullCDF(double mu, double sigma, double gamma, double upperlimit)`
`static double`	`weibullCDF(double mu, double sigma, double gamma, double lowerlimit, double upperlimit)`
`static double`	`weibullInverseCDF(double gamma, double prob)`
`static double`	`weibullInverseCDF(double sigma, double gamma, double prob)`
`static double`	`weibullInverseCDF(double mu, double sigma, double gamma, double prob)`
`static double`	`weibullMean(double mu, double sigma, double gamma)`
`static double`	`weibullMedian(double mu, double sigma, double gamma)`
`static double`	`weibullMode(double mu, double sigma, double gamma)`
`static double[]`	`weibullOrderStatisticMedians(double mu, double sigma, double gamma, int n)`
`static double[]`	`weibullOrderStatisticMedians(double sigma, double gamma, int n)`
`static double[]`	`weibullOrderStatisticMedians(double gamma, int n)`
`static double`	`weibullPDF(double mu, double sigma, double gamma, double x)`
`static double`	`weibullProb(double mu, double sigma, double gamma, double upperlimit)`
`static double`	`weibullProb(double mu, double sigma, double gamma, double lowerlimit, double upperlimit)`
`static double[]`	`weibullRand(double mu, double sigma, double gamma, int n)`
`static double[]`	`weibullRand(double mu, double sigma, double gamma, int n, long seed)`
`static double`	`weibullStandardDeviation(double sigma, double gamma)`
`static double`	`weibullStandDev(double sigma, double gamma)`
`double`	`weightedCoefficientOfVariation()`
`Complex`	`weightedGeneralisedMean_as_Complex(Complex m)`
`Complex`	`weightedGeneralisedMean_as_Complex(double m)`
`double`	`weightedGeneralisedMean_as_double(java.math.BigDecimal m)`
`double`	`weightedGeneralisedMean_as_double(double m)`
`double`	`weightedGeneralisedMean(java.math.BigDecimal m)`
`static double`	`weightedGeneralisedMean(java.math.BigDecimal[] aa, java.math.BigDecimal[] ww, java.math.BigDecimal m)`
`static double`	`weightedGeneralisedMean(java.math.BigDecimal[] aa, java.math.BigDecimal[] ww, double m)`
`static double`	`weightedGeneralisedMean(java.math.BigInteger[] aa, java.math.BigInteger[] ww, java.math.BigInteger m)`
`static double`	`weightedGeneralisedMean(java.math.BigInteger[] aa, java.math.BigInteger[] ww, double m)`
`static Complex`	`weightedGeneralisedMean(Complex[] aa, Complex[] ww, Complex m)`
`static Complex`	`weightedGeneralisedMean(Complex[] aa, Complex[] ww, double m)`
`double`	`weightedGeneralisedMean(double m)`
`static double`	`weightedGeneralisedMean(double[] aa, double[] ww, double m)`
`static float`	`weightedGeneralisedMean(float[] aa, float[] ww, float m)`
`Complex`	`weightedGeneralizedMean_as_Complex(Complex m)`
`Complex`	`weightedGeneralizedMean_as_Complex(double m)`
`double`	`weightedGeneralizedMean_as_double(java.math.BigDecimal m)`
`double`	`weightedGeneralizedMean_as_double(double m)`
`double`	`weightedGeneralizedMean(java.math.BigDecimal m)`
`double`	`weightedGeneralizedMean(double m)`
`Complex`	`weightedGeometricMean_as_Complex()`
`double`	`weightedGeometricMean_as_double()`
`double`	`weightedGeometricMean()`
`java.math.BigDecimal`	`weightedHarmonicMean_as_BigDecimal()`
`Complex`	`weightedHarmonicMean_as_Complex()`
`double`	`weightedHarmonicMean_as_double()`
`double`	`weightedHarmonicMean()`
`java.math.BigDecimal`	`weightedMean_as_BigDecimal()`
`Complex`	`weightedMean_as_Complex()`
`double`	`weightedMean_as_double()`
`double`	`weightedMean()`
`double`	`weightedRms()`
`double`	`weightedStandardDeviation_as_Complex_ConjugateCalcn()`
`Complex`	`weightedStandardDeviation_as_Complex()`
`double`	`weightedStandardDeviation_as_double()`
`double`	`weightedStandardDeviation_of_ComplexImaginaryParts()`
`double`	`weightedStandardDeviation_of_ComplexModuli()`
`double`	`weightedStandardDeviation_of_ComplexRealParts()`
`double`	`weightedStandardDeviation()`
`double`	`weightedStandardError_as_double()`
`double`	`weightedStandardError_of_ComplexImaginaryParts()`
`double`	`weightedStandardError_of_ComplexModuli()`
`double`	`weightedStandardError_of_ComplexRealParts()`
`double`	`weightedStandardError()`
`double`	`weightedStandarError_as_Complex_ConjugateCalcn()`
`Complex`	`weightedStandarError_as_Complex()`
`java.math.BigDecimal`	`weightedVariance_as_BigDecimal()`
`double`	`weightedVariance_as_Complex_ConjugateCalcn()`
`Complex`	`weightedVariance_as_Complex()`
`double`	`weightedVariance_as_double()`
`double`	`weightedVariance_of_ComplexImaginaryParts()`
`double`	`weightedVariance_of_ComplexModuli()`
`double`	`weightedVariance_of_ComplexRealParts()`
`double`	`weightedVariance()`
`static double`	`wilsonHilferty(double chiSquare, int nu)`

Methods inherited from class flanagan.math.ArrayMaths
abs, alphabeticSort, alphabeticSortIndices, antilog10, array_as_ArrayList, array_as_BigDecimal, array_as_BigInteger, array_as_byte, array_as_Byte, array_as_char, array_as_Character, array_as_Complex_columnMatrix, array_as_Complex_rowMatrix, array_as_Complex, array_as_degrees_phase_of_Phasor, array_as_double, array_as_Double, array_as_float, array_as_Float, array_as_imaginary_part_of_Complex, array_as_int, array_as_Integer, array_as_long, array_as_Long, array_as_magnitude_of_Phasor, array_as_Matrix_columnMatrix, array_as_Matrix_rowMatrix, array_as_modulus_of_Complex, array_as_Object, array_as_Phasor_columnMatrix, array_as_Phasor_rowMatrix, array_as_Phasor, array_as_radians_phase_of_Phasor, array_as_real_part_of_Complex, array_as_short, array_as_Short, array_as_String, array_as_Vector, array, arrayType, ceil, concatenate, concatenate, concatenate, concatenate, concatenate, concatenate, concatenate, concatenate, concatenate, concatenate, concatenate, concatenate, concatenate, concatenate, concatenate, concatenate, concatenate, concatenate, concatenate, concatenate, concatenate, exp, floor, getArray_as_ArrayList, getArray_as_BigDecimal, getArray_as_BigInteger, getArray_as_byte, getArray_as_Byte, getArray_as_char, getArray_as_Character, getArray_as_Complex_columnMatrix, getArray_as_Complex_rowMatrix, getArray_as_Complex, getArray_as_degrees_phase_of_Phasor, getArray_as_double, getArray_as_Double, getArray_as_float, getArray_as_Float, getArray_as_imaginay_part_of_Complex, getArray_as_int, getArray_as_Integer, getArray_as_long, getArray_as_Long, getArray_as_magnitude_of_Phasor, getArray_as_Matrix_columnMatrix, getArray_as_Matrix_rowMatrix, getArray_as_Object, getArray_as_Phasor_columnMatrix, getArray_as_Phasor_rowMatrix, getArray_as_Phasor, getArray_as_radians_phase_of_Phasor, getArray_as_real_part_of_Complex, getArray_as_short, getArray_as_Short, getArray_as_String, getArray_as_Vector, getMaximum_as_BigDecimal, getMaximum_as_BigInteger, getMaximum_as_byte, getMaximum_as_Byte, getMaximum_as_char, getMaximum_as_Character, getMaximum_as_double, getMaximum_as_Double, getMaximum_as_float, getMaximum_as_Float, getMaximum_as_int, getMaximum_as_Integer, getMaximum_as_long, getMaximum_as_Long, getMaximum_as_short, getMaximum_as_Short, getMaximum, getMaximumDifference_as_BigDecimal, getMaximumDifference_as_BigInteger, getMaximumDifference_as_byte, getMaximumDifference_as_Byte, getMaximumDifference_as_double, getMaximumDifference_as_Double, getMaximumDifference_as_float, getMaximumDifference_as_Float, getMaximumDifference_as_int, getMaximumDifference_as_Integer, getMaximumDifference_as_long, getMaximumDifference_as_Long, getMaximumDifference_as_short, getMaximumDifference_as_Short, getMaximumDifference, getMaximumIndex, getMinimum_as_BigDecimal, getMinimum_as_BigInteger, getMinimum_as_byte, getMinimum_as_Byte, getMinimum_as_char, getMinimum_as_Character, getMinimum_as_double, getMinimum_as_Double, getMinimum_as_float, getMinimum_as_Float, getMinimum_as_int, getMinimum_as_Integer, getMinimum_as_long, getMinimum_as_Long, getMinimum_as_short, getMinimum_as_Short, getMinimum, getMinimumDifference_as_BigDecimal, getMinimumDifference_as_BigInteger, getMinimumDifference_as_byte, getMinimumDifference_as_Byte, getMinimumDifference_as_double, getMinimumDifference_as_Double, getMinimumDifference_as_float, getMinimumDifference_as_Float, getMinimumDifference_as_int, getMinimumDifference_as_Integer, getMinimumDifference_as_long, getMinimumDifference_as_Long, getMinimumDifference_as_short, getMinimumDifference_as_Short, getMinimumDifference, getMinimumIndex, getProduct_as_BigDecimal, getProduct_as_BigInteger, getProduct_as_byte, getProduct_as_Byte, getProduct_as_Complex, getProduct_as_double, getProduct_as_Double, getProduct_as_float, getProduct_as_Float, getProduct_as_int, getProduct_as_Integer, getProduct_as_long, getProduct_as_Long, getProduct_as_Phasor, getProduct_as_short, getProduct_as_Short, getProduct_as_String, getProduct, getSum_as_BigDecimal, getSum_as_BigInteger, getSum_as_byte, getSum_as_Byte, getSum_as_Complex, getSum_as_double, getSum_as_Double, getSum_as_float, getSum_as_Float, getSum_as_int, getSum_as_Integer, getSum_as_long, getSum_as_Long, getSum_as_Phasor, getSum_as_short, getSum_as_Short, getSum_as_String, getSum, indexOf, indexOf, indexOf, indexOf, indexOf, indexOf, indexOf, indexOf, indexOf, indexOf, indexOf, indexOf, indexOf, indexOf, indexOf, indexOf, indexOf, indexOf, indexOf, indexSort, indicesOf, indicesOf, indicesOf, indicesOf, indicesOf, indicesOf, indicesOf, indicesOf, indicesOf, indicesOf, indicesOf, indicesOf, indicesOf, indicesOf, indicesOf, indicesOf, indicesOf, indicesOf, indicesOf, invert, isInteger, length, log, log10, log2, maximum_as_BigDecimal, maximum_as_BigInteger, maximum_as_byte, maximum_as_Byte, maximum_as_char, maximum_as_Character, maximum_as_double, maximum_as_Double, maximum_as_float, maximum_as_Float, maximum_as_int, maximum_as_Integer, maximum_as_long, maximum_as_Long, maximum_as_short, maximum_as_Short, maximum, maximumDifference_as_BigDecimal, maximumDifference_as_BigInteger, maximumDifference_as_byte, maximumDifference_as_Byte, maximumDifference_as_double, maximumDifference_as_Double, maximumDifference_as_float, maximumDifference_as_Float, maximumDifference_as_int, maximumDifference_as_Integer, maximumDifference_as_long, maximumDifference_as_Long, maximumDifference_as_short, maximumDifference_as_Short, maximumDifference, maximumIndex, minimum_as_BigDecimal, minimum_as_BigInteger, minimum_as_byte, minimum_as_Byte, minimum_as_char, minimum_as_Character, minimum_as_double, minimum_as_Double, minimum_as_float, minimum_as_Float, minimum_as_int, minimum_as_Integer, minimum_as_long, minimum_as_Long, minimum_as_short, minimum_as_Short, minimum, minimumDifference_as_BigDecimal, minimumDifference_as_BigInteger, minimumDifference_as_byte, minimumDifference_as_Byte, minimumDifference_as_double, minimumDifference_as_Double, minimumDifference_as_float, minimumDifference_as_Float, minimumDifference_as_int, minimumDifference_as_Integer, minimumDifference_as_long, minimumDifference_as_Long, minimumDifference_as_short, minimumDifference_as_Short, minimumDifference, minimumIndex, minus, minus, minus, minus, minus, minus, minus, minus, minus, minus, minus, minus, minus, minus, minus, minus, minus, minus, minus, minus, minus, minus, minus, minus, minus, minus, minus, minus, minus, minus, minus, minus, minus, minus, minus, minus, minusxLog10x, minusxLog2x, minusxLogEx, nearestIndex, nearestIndex, nearestIndex, nearestIndex, nearestIndex, nearestIndex, nearestIndex, nearestIndex, nearestIndex, nearestIndex, nearestIndex, nearestIndex, nearestIndex, nearestIndex, nearestIndex, nearestIndex, nearestValue, nearestValue, nearestValue, nearestValue, nearestValue, nearestValue, nearestValue, nearestValue, nearestValue, nearestValue, nearestValue, nearestValue, nearestValue, nearestValue, nearestValue, nearestValue, negate, oneOverSqrt, originalArrayTypes, originalIndices, over, over, over, over, over, over, over, over, over, over, over, over, over, over, over, over, plot, plus, plus, plus, plus, plus, plus, plus, plus, plus, plus, plus, plus, plus, plus, plus, plus, plus, plus, plus, plus, plus, plus, plus, plus, plus, plus, plus, plus, plus, plus, plus, plus, plus, plus, plus, plus, plus, plus, plus, plus, plus, plus, pow, pow, pow, pow, pow, pow, pow, print, println, product_as_BigDecimal, product_as_BigInteger, product_as_byte, product_as_Byte, product_as_Complex, product_as_double, product_as_Double, product_as_float, product_as_Float, product_as_int, product_as_Integer, product_as_long, product_as_Long, product_as_Phasor, product_as_short, product_as_Short, product_as_String, product, randomise, randomize, restoreMessages, restoreMessagesTotal, reverse, rint, sort, sort, sortByColumnInitial, sortEquals, sortEquals, sqrt, subarray_as_ArrayList, subarray_as_BigDecimal, subarray_as_BigInteger, subarray_as_byte, subarray_as_Byte, subarray_as_char, subarray_as_Character, subarray_as_Complex_columnMatrix, subarray_as_Complex_rowMatrix, subarray_as_Complex, subarray_as_degrees_phase_of_Phasor, subarray_as_double, subarray_as_Double, subarray_as_float, subarray_as_Float, subarray_as_imaginay_part_of_Complex, subarray_as_int, subarray_as_Integer, subarray_as_long, subarray_as_Long, subarray_as_magnitude_of_Phasor, subarray_as_Matrix_columnMatrix, subarray_as_Matrix_rowMatrix, subarray_as_modulus_of_Complex, subarray_as_Object, subarray_as_Phasor_columnMatrix, subarray_as_Phasor_rowMatrix, subarray_as_Phasor, subarray_as_radians_phase_of_Phasor, subarray_as_real_part_of_Complex, subarray_as_short, subarray_as_Short, subarray_as_String, subarray_as_Vector, sum_as_BigDecimal, sum_as_BigInteger, sum_as_byte, sum_as_Byte, sum_as_Complex, sum_as_double, sum_as_Double, sum_as_float, sum_as_Float, sum_as_int, sum_as_Integer, sum_as_long, sum_as_Long, sum_as_Phasor, sum_as_short, sum_as_Short, sum_as_String, sum, suppressMessages, suppressMessagesTotal, times, times, times, times, times, times, times, times, times, times, times, times, times, times, times, times, truncate, typeIndex, xLog10x, xLog2x, xLogEx

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail
- FPMIN
```
public static final double FPMIN
```
  See Also:
  
  Constant Field Values

Constructor Detail

Stat
```
public Stat()
```

Stat
```
public Stat(double[] xx)
```

Stat
```
public Stat(java.lang.Double[] xx)
```

Stat
```
public Stat(float[] xx)
```

Stat
```
public Stat(java.lang.Float[] xx)
```

Stat
```
public Stat(long[] xx)
```

Stat
```
public Stat(java.lang.Long[] xx)
```

Stat
```
public Stat(int[] xx)
```

Stat
```
public Stat(java.lang.Integer[] xx)
```

Stat
```
public Stat(short[] xx)
```

Stat
```
public Stat(java.lang.Short[] xx)
```

Stat
```
public Stat(byte[] xx)
```

Stat
```
public Stat(java.lang.Byte[] xx)
```

Stat

public Stat(java.math.BigDecimal[] xx)

Stat

public Stat(java.math.BigInteger[] xx)

Stat
```
public Stat(Complex[] xx)
```

Stat
```
public Stat(Phasor[] xx)
```

Stat
```
public Stat(java.lang.String[] xx)
```

Stat
```
public Stat(java.lang.Object[] xx)
```

Stat

public Stat(java.util.Vector<java.lang.Object> xx)

Stat

public Stat(java.util.ArrayList<java.lang.Object> xx)

Method Detail

convertToHighest
```
public void convertToHighest()
```
Overrides:

convertToHighest in class ArrayMaths

setWeightsToBigW
```
public void setWeightsToBigW()
```

setWeightsToLittleW
```
public void setWeightsToLittleW()
```

setDenominatorToN
```
public void setDenominatorToN()
```

setDenominatorToNminusOne

public void setDenominatorToNminusOne()

useEffectiveN
```
public void useEffectiveN()
```

useTrueN
```
public void useTrueN()
```

effectiveSampleNumber
```
public double effectiveSampleNumber()
```

effectiveSampleNumber_as_double

public double effectiveSampleNumber_as_double()

effectiveSampleNumber_as_BigDecimal

public java.math.BigDecimal effectiveSampleNumber_as_BigDecimal()

effectiveSampleNumber_as_Complex

public Complex effectiveSampleNumber_as_Complex()

trueSampleNumber
```
public int trueSampleNumber()
```

trueSampleNumber_as_int
```
public int trueSampleNumber_as_int()
```

trueSampleNumber_as_double

public double trueSampleNumber_as_double()

trueSampleNumber_as_BigDecimal

public java.math.BigDecimal trueSampleNumber_as_BigDecimal()

trueSampleNumber_as_Complex

public Complex trueSampleNumber_as_Complex()

convertBigWtoLittleW
```
public void convertBigWtoLittleW()
```

setWeights
```
public void setWeights(double[] xx)
```

setWeights

public void setWeights(java.lang.Double[] xx)

setWeights
```
public void setWeights(float[] xx)
```

setWeights

public void setWeights(java.lang.Float[] xx)

setWeights
```
public void setWeights(long[] xx)
```

setWeights

public void setWeights(java.lang.Long[] xx)

setWeights
```
public void setWeights(int[] xx)
```

setWeights

public void setWeights(java.lang.Integer[] xx)

setWeights
```
public void setWeights(short[] xx)
```

setWeights

public void setWeights(java.lang.Short[] xx)

setWeights
```
public void setWeights(byte[] xx)
```

setWeights

public void setWeights(java.lang.Byte[] xx)

setWeights

public void setWeights(java.math.BigDecimal[] xx)

setWeights

public void setWeights(java.math.BigInteger[] xx)

setWeights
```
public void setWeights(Complex[] xx)
```

setWeights
```
public void setWeights(Phasor[] xx)
```

setWeights

public void setWeights(java.lang.Object[] xx)

setWeights

public void setWeights(java.util.Vector<java.lang.Object> xx)

setWeights

public void setWeights(java.util.ArrayList<java.lang.Object> xx)

mean
```
public double mean()
```

mean_as_double
```
public double mean_as_double()
```

mean_as_BigDecimal

public java.math.BigDecimal mean_as_BigDecimal()

mean_as_Complex
```
public Complex mean_as_Complex()
```

weightedMean
```
public double weightedMean()
```

weightedMean_as_double

public double weightedMean_as_double()

weightedMean_as_BigDecimal

public java.math.BigDecimal weightedMean_as_BigDecimal()

weightedMean_as_Complex

public Complex weightedMean_as_Complex()

subtractMean
```
public double[] subtractMean()
```

subtractMean_as_double

public double[] subtractMean_as_double()

subtractMean_as_BigDecimal

public java.math.BigDecimal[] subtractMean_as_BigDecimal()

subtractMean_as_Complex

public Complex[] subtractMean_as_Complex()

subtractWeightedMean

public double[] subtractWeightedMean()

subtractWeightedMean_as_double

public double[] subtractWeightedMean_as_double()

subtractWeightedMean_as_BigDecimal

public java.math.BigDecimal[] subtractWeightedMean_as_BigDecimal()

subtractWeightedMean_as_Complex

public Complex[] subtractWeightedMean_as_Complex()

geometricMean
```
public double geometricMean()
```

geometricMean_as_double

public double geometricMean_as_double()

geometricMean_as_Complex

public Complex geometricMean_as_Complex()

weightedGeometricMean
```
public double weightedGeometricMean()
```

weightedGeometricMean_as_double

public double weightedGeometricMean_as_double()

weightedGeometricMean_as_Complex

public Complex weightedGeometricMean_as_Complex()

harmonicMean
```
public double harmonicMean()
```

harmonicMean_as_double

public double harmonicMean_as_double()

harmonicMean_as_BigDecimal

public java.math.BigDecimal harmonicMean_as_BigDecimal()

harmonicMean_as_Complex

public Complex harmonicMean_as_Complex()

weightedHarmonicMean
```
public double weightedHarmonicMean()
```

weightedHarmonicMean_as_double

public double weightedHarmonicMean_as_double()

weightedHarmonicMean_as_BigDecimal

public java.math.BigDecimal weightedHarmonicMean_as_BigDecimal()

weightedHarmonicMean_as_Complex

public Complex weightedHarmonicMean_as_Complex()

generalizedMean

public double generalizedMean(double m)

generalizedMean_as_double

public double generalizedMean_as_double(double m)

generalizedMean

public double generalizedMean(java.math.BigDecimal m)

generalizedMean_as_double

public double generalizedMean_as_double(java.math.BigDecimal m)

generalizedMean_as_Complex

public Complex generalizedMean_as_Complex(double m)

generalizedMean_as_Complex

public Complex generalizedMean_as_Complex(Complex m)

generalisedMean

public double generalisedMean(double m)

generalisedMean_as_double

public double generalisedMean_as_double(double m)

generalisedMean

public double generalisedMean(java.math.BigDecimal m)

generalisedMean_as_double

public double generalisedMean_as_double(java.math.BigDecimal m)

generalisedMean_as_Complex

public Complex generalisedMean_as_Complex(double m)

generalisedMean_as_Complex

public Complex generalisedMean_as_Complex(Complex m)

weightedGeneralizedMean

public double weightedGeneralizedMean(double m)

weightedGeneralizedMean_as_double

public double weightedGeneralizedMean_as_double(double m)

weightedGeneralizedMean

public double weightedGeneralizedMean(java.math.BigDecimal m)

weightedGeneralizedMean_as_double

public double weightedGeneralizedMean_as_double(java.math.BigDecimal m)

weightedGeneralizedMean_as_Complex

public Complex weightedGeneralizedMean_as_Complex(double m)

weightedGeneralizedMean_as_Complex

public Complex weightedGeneralizedMean_as_Complex(Complex m)

weightedGeneralisedMean

public double weightedGeneralisedMean(double m)

weightedGeneralisedMean_as_double

public double weightedGeneralisedMean_as_double(double m)

weightedGeneralisedMean

public double weightedGeneralisedMean(java.math.BigDecimal m)

weightedGeneralisedMean_as_double

public double weightedGeneralisedMean_as_double(java.math.BigDecimal m)

weightedGeneralisedMean_as_Complex

public Complex weightedGeneralisedMean_as_Complex(double m)

weightedGeneralisedMean_as_Complex

public Complex weightedGeneralisedMean_as_Complex(Complex m)

interQuartileMean
```
public double interQuartileMean()
```

interQuartileMean_as_double

public double interQuartileMean_as_double()

interQuartileMean_as_BigDecimal

public java.math.BigDecimal interQuartileMean_as_BigDecimal()

median
```
public double median()
```

median_as_double
```
public double median_as_double()
```

median_as_BigDecimal

public java.math.BigDecimal median_as_BigDecimal()

rms
```
public double rms()
```

weightedRms
```
public double weightedRms()
```

momentSkewness
```
public double momentSkewness()
```

momentSkewness_as_double

public double momentSkewness_as_double()

medianSkewness
```
public double medianSkewness()
```

medianSkewness_as_double

public double medianSkewness_as_double()

quartileSkewness
```
public double quartileSkewness()
```

quartileSkewness_as_double

public double quartileSkewness_as_double()

quartileSkewness_as_BigDecimal

public java.math.BigDecimal quartileSkewness_as_BigDecimal()

kurtosis
```
public double kurtosis()
```

kurtosis_as_double
```
public double kurtosis_as_double()
```

curtosis
```
public double curtosis()
```

curtosis_as_double
```
public double curtosis_as_double()
```

kurtosisExcess
```
public double kurtosisExcess()
```

excessKurtosis
```
public double excessKurtosis()
```

excessCurtosis
```
public double excessCurtosis()
```

kurtosisExcess_as_double

public double kurtosisExcess_as_double()

excessKurtosis_as_double

public double excessKurtosis_as_double()

curtosisExcess
```
public double curtosisExcess()
```

curtosisExcess_as_double

public double curtosisExcess_as_double()

excessCurtosis_as_double

public double excessCurtosis_as_double()

kurtosis_as_BigDecimal

public java.math.BigDecimal kurtosis_as_BigDecimal()

curtosis_as_BigDecimal

public java.math.BigDecimal curtosis_as_BigDecimal()

kurtosisExcess_as_BigDecimal

public java.math.BigDecimal kurtosisExcess_as_BigDecimal()

excessKurtosis_as_BigDecimal

public java.math.BigDecimal excessKurtosis_as_BigDecimal()

curtosisExcess_as_BigDecimal

public java.math.BigDecimal curtosisExcess_as_BigDecimal()

excessCurtosis_as_BigDecimal

public java.math.BigDecimal excessCurtosis_as_BigDecimal()

variance
```
public double variance()
```

variance_as_double
```
public double variance_as_double()
```

variance_as_BigDecimal

public java.math.BigDecimal variance_as_BigDecimal()

variance_as_Complex
```
public Complex variance_as_Complex()
```

variance_as_Complex_ConjugateCalcn

public double variance_as_Complex_ConjugateCalcn()

variance_of_ComplexModuli

public double variance_of_ComplexModuli()

variance_of_ComplexRealParts

public double variance_of_ComplexRealParts()

variance_of_ComplexImaginaryParts

public double variance_of_ComplexImaginaryParts()

weightedVariance
```
public double weightedVariance()
```

weightedVariance_as_double

public double weightedVariance_as_double()

weightedVariance_as_BigDecimal

public java.math.BigDecimal weightedVariance_as_BigDecimal()

weightedVariance_as_Complex

public Complex weightedVariance_as_Complex()

weightedVariance_as_Complex_ConjugateCalcn

public double weightedVariance_as_Complex_ConjugateCalcn()

weightedVariance_of_ComplexModuli

public double weightedVariance_of_ComplexModuli()

weightedVariance_of_ComplexRealParts

public double weightedVariance_of_ComplexRealParts()

weightedVariance_of_ComplexImaginaryParts

public double weightedVariance_of_ComplexImaginaryParts()

standardDeviation
```
public double standardDeviation()
```

standardDeviation_as_double

public double standardDeviation_as_double()

standardDeviation_as_Complex

public Complex standardDeviation_as_Complex()

standardDeviation_as_Complex_ConjugateCalcn

public double standardDeviation_as_Complex_ConjugateCalcn()

standardDeviation_of_ComplexModuli

public double standardDeviation_of_ComplexModuli()

standardDeviation_of_ComplexRealParts

public double standardDeviation_of_ComplexRealParts()

standardDeviation_of_ComplexImaginaryParts

public double standardDeviation_of_ComplexImaginaryParts()

weightedStandardDeviation

public double weightedStandardDeviation()

weightedStandardDeviation_as_double

public double weightedStandardDeviation_as_double()

weightedStandardDeviation_as_Complex

public Complex weightedStandardDeviation_as_Complex()

weightedStandardDeviation_as_Complex_ConjugateCalcn

public double weightedStandardDeviation_as_Complex_ConjugateCalcn()

weightedStandardDeviation_of_ComplexModuli

public double weightedStandardDeviation_of_ComplexModuli()

weightedStandardDeviation_of_ComplexRealParts

public double weightedStandardDeviation_of_ComplexRealParts()

weightedStandardDeviation_of_ComplexImaginaryParts

public double weightedStandardDeviation_of_ComplexImaginaryParts()

standardError
```
public double standardError()
```

standardError_as_double

public double standardError_as_double()

standardError_as_Complex

public Complex standardError_as_Complex()

standardError_as_Complex_ConjugateCalcn

public double standardError_as_Complex_ConjugateCalcn()

standardError_of_ComplexModuli

public double standardError_of_ComplexModuli()

standardError_of_ComplexRealParts

public double standardError_of_ComplexRealParts()

standardError_of_ComplexImaginaryParts

public double standardError_of_ComplexImaginaryParts()

weightedStandardError
```
public double weightedStandardError()
```

weightedStandardError_as_double

public double weightedStandardError_as_double()

weightedStandarError_as_Complex

public Complex weightedStandarError_as_Complex()

weightedStandarError_as_Complex_ConjugateCalcn

public double weightedStandarError_as_Complex_ConjugateCalcn()

weightedStandardError_of_ComplexModuli

public double weightedStandardError_of_ComplexModuli()

weightedStandardError_of_ComplexRealParts

public double weightedStandardError_of_ComplexRealParts()

weightedStandardError_of_ComplexImaginaryParts

public double weightedStandardError_of_ComplexImaginaryParts()

standardize
```
public double[] standardize()
```

standardise
```
public double[] standardise()
```

scale

public double[] scale(double mean,
                      double sd)

volatilityLogChange
```
public double volatilityLogChange()
```

volatilityPerCentChange

public double volatilityPerCentChange()

coefficientOfVariation

public double coefficientOfVariation()

weightedCoefficientOfVariation

public double weightedCoefficientOfVariation()

shannonEntropy
```
public double shannonEntropy()
```

shannonEntropyBit
```
public double shannonEntropyBit()
```

shannonEntropyNat
```
public double shannonEntropyNat()
```

shannonEntropyDit
```
public double shannonEntropyDit()
```

renyiEntropy

public double renyiEntropy(double alpha)

renyiEntropyBit

public double renyiEntropyBit(double alpha)

renyiEntropyNat

public double renyiEntropyNat(double alpha)

renyiEntropyDit

public double renyiEntropyDit(double alpha)

tsallisEntropyNat

public double tsallisEntropyNat(double q)

generalizedEntropyOneNat

public double generalizedEntropyOneNat(double q,
                                       double r)

generalisedEntropyOneNat

public double generalisedEntropyOneNat(double q,
                                       double r)

upperOutliersAnscombe

public java.util.ArrayList<java.lang.Object> upperOutliersAnscombe(double constant)

upperOutliersAnscombe_as_double

public java.util.ArrayList<java.lang.Object> upperOutliersAnscombe_as_double(double constant)

upperOutliersAnscombe

public java.util.ArrayList<java.lang.Object> upperOutliersAnscombe(java.math.BigDecimal constant)

upperOutliersAnscombe_as_BigDecimal

public java.util.ArrayList<java.lang.Object> upperOutliersAnscombe_as_BigDecimal(java.math.BigDecimal constant)

upperOutliersAnscombe

public java.util.ArrayList<java.lang.Object> upperOutliersAnscombe(java.math.BigInteger constant)

upperOutliersAnscombe_as_BigDecimal

public java.util.ArrayList<java.lang.Object> upperOutliersAnscombe_as_BigDecimal(java.math.BigInteger constant)

lowerOutliersAnscombe

public java.util.ArrayList<java.lang.Object> lowerOutliersAnscombe(double constant)

lowerOutliersAnscombe_as_double

public java.util.ArrayList<java.lang.Object> lowerOutliersAnscombe_as_double(double constant)

lowerOutliersAnscombe

public java.util.ArrayList<java.lang.Object> lowerOutliersAnscombe(java.math.BigDecimal constant)

lowerOutliersAnscombe_as_BigDecimal

public java.util.ArrayList<java.lang.Object> lowerOutliersAnscombe_as_BigDecimal(java.math.BigDecimal constant)

lowerOutliersAnscombe

public java.util.ArrayList<java.lang.Object> lowerOutliersAnscombe(java.math.BigInteger constant)

lowerOutliersAnscombe_as_BigDecimal

public java.util.ArrayList<java.lang.Object> lowerOutliersAnscombe_as_BigDecimal(java.math.BigInteger constant)

setStaticWeightsToBigW

public static void setStaticWeightsToBigW()

setStaticWeightsToLittleW

public static void setStaticWeightsToLittleW()

convertBigWtoLittleW

public static double[] convertBigWtoLittleW(double[] bigW)

convertBigWtoLittleW

public static float[] convertBigWtoLittleW(float[] bigW)

convertBigWtoLittleW

public static Complex[] convertBigWtoLittleW(Complex[] bigW)

convertBigWtoLittleW

public static double[] convertBigWtoLittleW(java.math.BigDecimal[] bigW)

convertBigWtoLittleW

public static double[] convertBigWtoLittleW(java.math.BigInteger[] bigW)

setStaticDenominatorToN

public static void setStaticDenominatorToN()

setStaticDenominatorToNminusOne

public static void setStaticDenominatorToNminusOne()

useStaticEffectiveN

public static void useStaticEffectiveN()

useStaticTrueN
```
public static void useStaticTrueN()
```

effectiveSampleNumber

public static double effectiveSampleNumber(double[] ww)

effectiveSampleNumber

public static float effectiveSampleNumber(float[] ww)

effectiveSampleNumber

public static Complex effectiveSampleNumber(Complex[] ww)

effectiveSampleNumberConjugateCalcn

public static double effectiveSampleNumberConjugateCalcn(Complex[] ww)

effectiveSampleNumber

public static java.math.BigDecimal effectiveSampleNumber(java.math.BigDecimal[] ww)

effectiveSampleNumber

public static java.math.BigDecimal effectiveSampleNumber(java.math.BigInteger[] ww)

mean

public static double mean(double[] aa)

mean
```
public static float mean(float[] aa)
```

mean
```
public static double mean(long[] aa)
```

mean
```
public static double mean(int[] aa)
```

mean

public static double mean(short[] aa)

mean
```
public static double mean(byte[] aa)
```

mean

public static Complex mean(Complex[] aa)

mean

public static java.math.BigDecimal mean(java.math.BigDecimal[] aa)

mean

public static java.math.BigDecimal mean(java.math.BigInteger[] aa)

mean

public static double mean(double[] aa,
                          double[] ww)

mean

public static float mean(float[] aa,
                         float[] ww)

mean

public static Complex mean(Complex[] aa,
                           Complex[] ww)

mean

public static java.math.BigDecimal mean(java.math.BigDecimal[] aa,
                                        java.math.BigDecimal[] ww)

mean

public static java.math.BigDecimal mean(java.math.BigInteger[] aa,
                                        java.math.BigInteger[] ww)

subtractMean

public static double[] subtractMean(double[] array)

subtractMean

public static float[] subtractMean(float[] array)

subtractMean

public static java.math.BigDecimal[] subtractMean(java.math.BigDecimal[] array)

subtractMean

public static java.math.BigDecimal[] subtractMean(java.math.BigInteger[] array)

subtractMean

public static Complex[] subtractMean(Complex[] array)

subtractMean

public static double[] subtractMean(double[] array,
                                    double[] weights)

subtractMean

public static float[] subtractMean(float[] array,
                                   float[] weights)

subtractMean

public static java.math.BigDecimal[] subtractMean(java.math.BigDecimal[] array,
                                                  java.math.BigDecimal[] weights)

subtractMean

public static java.math.BigDecimal[] subtractMean(java.math.BigInteger[] array,
                                                  java.math.BigInteger[] weights)

subtractMean

public static Complex[] subtractMean(Complex[] array,
                                     Complex[] weights)

geometricMean

public static double geometricMean(java.math.BigDecimal[] aa)

geometricMean

public static double geometricMean(java.math.BigInteger[] aa)

geometricMean

public static Complex geometricMean(Complex[] aa)

geometricMean

public static double geometricMean(double[] aa)

geometricMean

public static float geometricMean(float[] aa)

geometricMean

public static Complex geometricMean(Complex[] aa,
                                    Complex[] ww)

geometricMean

public static double geometricMean(java.math.BigDecimal[] aa,
                                   java.math.BigDecimal[] ww)

geometricMean

public static double geometricMean(java.math.BigInteger[] aa,
                                   java.math.BigInteger[] ww)

geometricMean

public static double geometricMean(double[] aa,
                                   double[] ww)

geometricMean

public static float geometricMean(float[] aa,
                                  float[] ww)

harmonicMean

public static java.math.BigDecimal harmonicMean(java.math.BigDecimal[] aa)

harmonicMean

public static java.math.BigDecimal harmonicMean(java.math.BigInteger[] aa)

harmonicMean

public static Complex harmonicMean(Complex[] aa)

harmonicMean

public static double harmonicMean(double[] aa)

harmonicMean

public static float harmonicMean(float[] aa)

harmonicMean

public static java.math.BigDecimal harmonicMean(java.math.BigDecimal[] aa,
                                                java.math.BigDecimal[] ww)

harmonicMean

public static java.math.BigDecimal harmonicMean(java.math.BigInteger[] aa,
                                                java.math.BigInteger[] ww)

harmonicMean

public static Complex harmonicMean(Complex[] aa,
                                   Complex[] ww)

harmonicMean

public static double harmonicMean(double[] aa,
                                  double[] ww)

harmonicMean

public static float harmonicMean(float[] aa,
                                 float[] ww)

generalizedMean

public static Complex generalizedMean(Complex[] aa,
                                      double m)

generalizedMean

public static Complex generalizedMean(Complex[] aa,
                                      Complex m)

generalizedMean

public static double generalizedMean(java.math.BigDecimal[] aa,
                                     double m)

generalizedMean

public static double generalizedMean(java.math.BigDecimal[] aa,
                                     java.math.BigDecimal m)

generalizedMean

public static double generalizedMean(java.math.BigInteger[] aa,
                                     double m)

generalizedMean

public static double generalizedMean(java.math.BigInteger[] aa,
                                     java.math.BigInteger m)

generalizedMean

public static double generalizedMean(double[] aa,
                                     double m)

generalizedMean

public static float generalizedMean(float[] aa,
                                    float m)

generalisedMean

public static Complex generalisedMean(Complex[] aa,
                                      double m)

generalisedMean

public static Complex generalisedMean(Complex[] aa,
                                      Complex m)

generalisedMean

public static double generalisedMean(java.math.BigDecimal[] aa,
                                     double m)

generalisedMean

public static double generalisedMean(java.math.BigDecimal[] aa,
                                     java.math.BigDecimal m)

generalisedMean

public static double generalisedMean(java.math.BigInteger[] aa,
                                     double m)

generalisedMean

public static double generalisedMean(java.math.BigInteger[] aa,
                                     java.math.BigInteger m)

generalisedMean

public static double generalisedMean(double[] aa,
                                     double m)

generalisedMean

public static float generalisedMean(float[] aa,
                                    float m)

generalisedMean

public static Complex generalisedMean(Complex[] aa,
                                      Complex[] ww,
                                      double m)

generalisedMean

public static Complex generalisedMean(Complex[] aa,
                                      Complex[] ww,
                                      Complex m)

generalisedMean

public static double generalisedMean(java.math.BigDecimal[] aa,
                                     java.math.BigDecimal[] ww,
                                     double m)

generalisedMean

public static double generalisedMean(java.math.BigDecimal[] aa,
                                     java.math.BigDecimal[] ww,
                                     java.math.BigDecimal m)

generalisedMean

public static double generalisedMean(java.math.BigInteger[] aa,
                                     java.math.BigInteger[] ww,
                                     double m)

generalisedMean

public static double generalisedMean(java.math.BigInteger[] aa,
                                     java.math.BigInteger[] ww,
                                     java.math.BigInteger m)

generalisedMean

public static double generalisedMean(double[] aa,
                                     double[] ww,
                                     double m)

generalisedMean

public static float generalisedMean(float[] aa,
                                    float[] ww,
                                    float m)

weightedGeneralisedMean

public static Complex weightedGeneralisedMean(Complex[] aa,
                                              Complex[] ww,
                                              double m)

weightedGeneralisedMean

public static Complex weightedGeneralisedMean(Complex[] aa,
                                              Complex[] ww,
                                              Complex m)

weightedGeneralisedMean

public static double weightedGeneralisedMean(java.math.BigDecimal[] aa,
                                             java.math.BigDecimal[] ww,
                                             double m)

weightedGeneralisedMean

public static double weightedGeneralisedMean(java.math.BigDecimal[] aa,
                                             java.math.BigDecimal[] ww,
                                             java.math.BigDecimal m)

weightedGeneralisedMean

public static double weightedGeneralisedMean(java.math.BigInteger[] aa,
                                             java.math.BigInteger[] ww,
                                             double m)

weightedGeneralisedMean

public static double weightedGeneralisedMean(java.math.BigInteger[] aa,
                                             java.math.BigInteger[] ww,
                                             java.math.BigInteger m)

weightedGeneralisedMean

public static double weightedGeneralisedMean(double[] aa,
                                             double[] ww,
                                             double m)

weightedGeneralisedMean

public static float weightedGeneralisedMean(float[] aa,
                                            float[] ww,
                                            float m)

interQuartileMean

public static java.math.BigDecimal interQuartileMean(java.math.BigDecimal[] aa)

interQuartileMean

public static java.math.BigDecimal interQuartileMean(java.math.BigInteger[] aa)

interQuartileMean

public static double interQuartileMean(double[] aa)

interQuartileMean

public static float interQuartileMean(float[] aa)

rms

public static double rms(double[] aa)

rms
```
public static float rms(float[] aa)
```

rms

public static double rms(java.math.BigDecimal[] aa)

rms

public static double rms(java.math.BigInteger[] aa)

rms

public static double rms(double[] aa,
                         double[] ww)

rms

public static float rms(float[] aa,
                        float[] ww)

rms

public static double rms(java.math.BigDecimal[] aa,
                         java.math.BigDecimal[] ww)

rms

public static double rms(java.math.BigInteger[] aa,
                         java.math.BigInteger[] ww)

median

public static java.math.BigDecimal median(java.math.BigDecimal[] aa)

secondQuartile

public static java.math.BigDecimal secondQuartile(java.math.BigDecimal[] aa)

median

public static java.math.BigInteger median(java.math.BigInteger[] aa)

secondQuartile

public static java.math.BigInteger secondQuartile(java.math.BigInteger[] aa)

median

public static double median(double[] aa)

secondQuartile

public static double secondQuartile(double[] aa)

median

public static float median(float[] aa)

secondQuartile

public static float secondQuartile(float[] aa)

median

public static double median(int[] aa)

secondQuartile

public static double secondQuartile(int[] aa)

median

public static double median(long[] aa)

secondQuartile

public static double secondQuartile(long[] aa)

standardDeviation

public static double standardDeviation(java.math.BigDecimal[] aa)

standardDeviation

public static double standardDeviation(java.math.BigInteger[] aa)

standardDeviation

public static Complex standardDeviation(Complex[] aa)

standardDeviationConjugateCalcn

public static double standardDeviationConjugateCalcn(Complex[] aa)

standardDeviationModuli

public static double standardDeviationModuli(Complex[] aa)

standardDeviationRealParts

public static double standardDeviationRealParts(Complex[] aa)

standardDeviationImaginaryParts

public static double standardDeviationImaginaryParts(Complex[] aa)

standardDeviation

public static double standardDeviation(double[] aa)

standardDeviation

public static float standardDeviation(float[] aa)

standardDeviation

public static double standardDeviation(int[] aa)

standardDeviation

public static double standardDeviation(long[] aa)

standardDeviation

public static Complex standardDeviation(Complex[] aa,
                                        Complex[] ww)

standardDeviationConjugateCalcn

public static double standardDeviationConjugateCalcn(Complex[] aa,
                                                     Complex[] ww)

standardDeviationModuli

public static double standardDeviationModuli(Complex[] aa,
                                             Complex[] ww)

standardDeviationRealParts

public static double standardDeviationRealParts(Complex[] aa,
                                                Complex[] ww)

standardDeviationImaginaryParts

public static double standardDeviationImaginaryParts(Complex[] aa,
                                                     Complex[] ww)

standardDeviation

public static double standardDeviation(java.math.BigDecimal[] aa,
                                       java.math.BigDecimal[] ww)

standardDeviation

public static double standardDeviation(java.math.BigInteger[] aa,
                                       java.math.BigInteger[] ww)

standardDeviation

public static double standardDeviation(double[] aa,
                                       double[] ww)

standardDeviation

public static float standardDeviation(float[] aa,
                                      float[] ww)

volatilityLogChange

public static double volatilityLogChange(java.math.BigDecimal[] array)

volatilityLogChange

public static double volatilityLogChange(java.math.BigInteger[] array)

volatilityLogChange

public static double volatilityLogChange(double[] array)

volatilityLogChange

public static float volatilityLogChange(float[] array)

volatilityPerCentChange

public static double volatilityPerCentChange(java.math.BigDecimal[] array)

volatilityPerCentChange

public static double volatilityPerCentChange(java.math.BigInteger[] array)

volatilityPerCentChange

public static double volatilityPerCentChange(double[] array)

volatilityPerCentChange

public static double volatilityPerCentChange(float[] array)

coefficientOfVariation

public static double coefficientOfVariation(java.math.BigInteger[] array)

coefficientOfVariation

public static double coefficientOfVariation(java.math.BigDecimal[] array)

coefficientOfVariation

public static double coefficientOfVariation(double[] array)

coefficientOfVariation

public static float coefficientOfVariation(float[] array)

coefficientOfVariation

public static double coefficientOfVariation(java.math.BigInteger[] array,
                                            java.math.BigInteger[] weight)

coefficientOfVariation

public static double coefficientOfVariation(java.math.BigDecimal[] array,
                                            java.math.BigDecimal[] weight)

coefficientOfVariation

public static double coefficientOfVariation(double[] array,
                                            double[] weight)

coefficientOfVariation

public static float coefficientOfVariation(float[] array,
                                           float[] weight)

standardize

public static double[] standardize(double[] aa)

standardise

public static double[] standardise(double[] aa)

standardize

public static float[] standardize(float[] aa)

standardise

public static float[] standardise(float[] aa)

standardize

public static double[] standardize(long[] aa)

standardise

public static double[] standardise(long[] aa)

standardize

public static double[] standardize(int[] aa)

standardise

public static double[] standardise(int[] aa)

standardize

public static double[] standardize(java.math.BigDecimal[] aa)

standardise

public static double[] standardise(java.math.BigDecimal[] aa)

standardize

public static double[] standardize(java.math.BigInteger[] aa)

standardise

public static double[] standardise(java.math.BigInteger[] aa)

scale

public static double[] scale(double[] aa,
                             double mean,
                             double sd)

scale

public static float[] scale(float[] aa,
                            float mean,
                            float sd)

scale

public static double[] scale(long[] aa,
                             double mean,
                             double sd)

scale

public static double[] scale(int[] aa,
                             double mean,
                             double sd)

scale

public static double[] scale(java.math.BigDecimal[] aa,
                             double mean,
                             double sd)

scale

public static double[] scale(java.math.BigInteger[] aa,
                             double mean,
                             double sd)

momentSkewness

public static double momentSkewness(double[] aa)

momentSkewness

public static float momentSkewness(float[] aa)

momentSkewness

public static double momentSkewness(java.math.BigDecimal[] aa)

momentSkewness

public static double momentSkewness(long[] aa)

momentSkewness

public static double momentSkewness(int[] aa)

medianSkewness

public static double medianSkewness(double[] aa)

medianSkewness

public static float medianSkewness(float[] aa)

medianSkewness

public static double medianSkewness(java.math.BigDecimal[] aa)

medianSkewness

public static double medianSkewness(long[] aa)

medianSkewness

public static double medianSkewness(int[] aa)

quartileSkewness

public static double quartileSkewness(double[] aa)

quartileSkewness

public static float quartileSkewness(float[] aa)

quartileSkewness

public static java.math.BigDecimal quartileSkewness(java.math.BigDecimal[] aa)

quartileSkewness

public static java.math.BigDecimal quartileSkewness(java.math.BigInteger[] aa)

quartileSkewness

public static double quartileSkewness(long[] aa)

quartileSkewness

public static double quartileSkewness(int[] aa)

kurtosis

public static double kurtosis(double[] aa)

curtosis

public static double curtosis(double[] aa)

kurtosisExcess

public static double kurtosisExcess(double[] aa)

curtosisExcess

public static double curtosisExcess(double[] aa)

excessKurtosis

public static double excessKurtosis(double[] aa)

excessCurtosis

public static double excessCurtosis(double[] aa)

kurtosis

public static float kurtosis(float[] aa)

curtosis

public static float curtosis(float[] aa)

kurtosisExcess

public static float kurtosisExcess(float[] aa)

curtosisExcess

public static float curtosisExcess(float[] aa)

excessKurtosis

public static float excessKurtosis(float[] aa)

excessCurtosis

public static float excessCurtosis(float[] aa)

kurtosis

public static java.math.BigDecimal kurtosis(java.math.BigInteger[] aa)

curtosis

public static java.math.BigDecimal curtosis(java.math.BigInteger[] aa)

kurtosisExcess

public static java.math.BigDecimal kurtosisExcess(java.math.BigInteger[] aa)

curtosisExcess

public static java.math.BigDecimal curtosisExcess(java.math.BigInteger[] aa)

excessKurtosis

public static java.math.BigDecimal excessKurtosis(java.math.BigInteger[] aa)

excessCurtosis

public static java.math.BigDecimal excessCurtosis(java.math.BigInteger[] aa)

kurtosis

public static java.math.BigDecimal kurtosis(java.math.BigDecimal[] aa)

curtosis

public static java.math.BigDecimal curtosis(java.math.BigDecimal[] aa)

kurtosisExcess

public static java.math.BigDecimal kurtosisExcess(java.math.BigDecimal[] aa)

curtosisExcess

public static java.math.BigDecimal curtosisExcess(java.math.BigDecimal[] aa)

excessCurtosis

public static java.math.BigDecimal excessCurtosis(java.math.BigDecimal[] aa)

excessKurtosis

public static java.math.BigDecimal excessKurtosis(java.math.BigDecimal[] aa)

kurtosis

public static double kurtosis(long[] aa)

curtosis

public static double curtosis(long[] aa)

kurtosisExcess

public static double kurtosisExcess(long[] aa)

curtosisExcess

public static double curtosisExcess(long[] aa)

excessCurtosis

public static double excessCurtosis(long[] aa)

excessKurtosis

public static double excessKurtosis(long[] aa)

kurtosis

public static double kurtosis(int[] aa)

curtosis

public static double curtosis(int[] aa)

kurtosisExcess

public static double kurtosisExcess(int[] aa)

curtosisExcess

public static double curtosisExcess(int[] aa)

excessCurtosis

public static double excessCurtosis(int[] aa)

excessKurtosis

public static double excessKurtosis(int[] aa)

variance

public static java.math.BigDecimal variance(java.math.BigDecimal[] aa)

variance

public static java.math.BigDecimal variance(java.math.BigInteger[] aa)

variance

public static Complex variance(Complex[] aa)

varianceConjugateCalcn

public static double varianceConjugateCalcn(Complex[] aa)

varianceModuli

public static double varianceModuli(Complex[] aa)

varianceRealParts

public static double varianceRealParts(Complex[] aa)

varianceImaginaryParts

public static double varianceImaginaryParts(Complex[] aa)

variance

public static double variance(double[] aa)

variance

public static float variance(float[] aa)

variance

public static double variance(int[] aa)

variance

public static double variance(long[] aa)

variance

public static double variance(double[] aa,
                              double[] ww)

variance

public static float variance(float[] aa,
                             float[] ww)

variance

public static Complex variance(Complex[] aa,
                               Complex[] ww)

varianceConjugateCalcn

public static double varianceConjugateCalcn(Complex[] aa,
                                            Complex[] ww)

varianceModuli

public static double varianceModuli(Complex[] aa,
                                    Complex[] ww)

varianceRealParts

public static double varianceRealParts(Complex[] aa,
                                       Complex[] ww)

varianceImaginaryParts

public static double varianceImaginaryParts(Complex[] aa,
                                            Complex[] ww)

variance

public static java.math.BigDecimal variance(java.math.BigDecimal[] aa,
                                            java.math.BigDecimal[] ww)

variance

public static java.math.BigDecimal variance(java.math.BigInteger[] aa,
                                            java.math.BigInteger[] ww)

standardError

public static double standardError(java.math.BigDecimal[] aa)

standardError

public static double standardError(java.math.BigInteger[] aa)

standardError

public static Complex standardError(Complex[] aa)

standardErrorConjugateCalcn

public static double standardErrorConjugateCalcn(Complex[] aa)

standardErrorModuli

public static double standardErrorModuli(Complex[] aa)

standardErrorRealParts

public static double standardErrorRealParts(Complex[] aa)

standardErrorImaginaryParts

public static double standardErrorImaginaryParts(Complex[] aa)

standardError

public static double standardError(double[] aa)

standardError

public static float standardError(float[] aa)

standardError

public static double standardError(int[] aa)

standardError

public static double standardError(long[] aa)

standardError

public static Complex standardError(Complex[] aa,
                                    Complex[] ww)

standardErrorConjugateCalcn

public static double standardErrorConjugateCalcn(Complex[] aa,
                                                 Complex[] ww)

standardErrorModuli

public static double standardErrorModuli(Complex[] aa,
                                         Complex[] ww)

standardErrorRealParts

public static double standardErrorRealParts(Complex[] aa,
                                            Complex[] ww)

standardErrorImaginaryParts

public static double standardErrorImaginaryParts(Complex[] aa,
                                                 Complex[] ww)

standardError

public static double standardError(java.math.BigDecimal[] aa,
                                   java.math.BigDecimal[] ww)

standardError

public static double standardError(java.math.BigInteger[] aa,
                                   java.math.BigInteger[] ww)

standardError

public static double standardError(double[] aa,
                                   double[] ww)

standardError

public static float standardError(float[] aa,
                                  float[] ww)

covariance

public static double covariance(double[] xx,
                                double[] yy)

covariance

public static float covariance(float[] xx,
                               float[] yy)

covariance

public static double covariance(int[] xx,
                                int[] yy)

covariance

public static double covariance(long[] xx,
                                long[] yy)

covariance

public static double covariance(double[] xx,
                                double[] yy,
                                double[] ww)

corrCoeff

public static double corrCoeff(double[] xx,
                               double[] yy)

corrCoeff

public static float corrCoeff(float[] x,
                              float[] y)

corrCoeff

public static double corrCoeff(int[] x,
                               int[] y)

corrCoeff

public static double corrCoeff(double[] x,
                               double[] y,
                               double[] w)

corrCoeff

public static double corrCoeff(int element00,
                               int element01,
                               int element10,
                               int element11)

corrCoeff

public static double corrCoeff(int[][] freqMatrix)

linearCorrCoeffProb

public static double linearCorrCoeffProb(double rCoeff,
                                         int nu)

corrCoeffProb

public static double corrCoeffProb(double rCoeff,
                                   int nu)

linearCorrCoeff

public static double linearCorrCoeff(double rCoeff,
                                     int nu)

corrCoeffPDF

public static double corrCoeffPDF(double rCoeff,
                                  int nu)

corrCoeffPdf

public static double corrCoeffPdf(double rCoeff,
                                  int nu)

shannonEntropy

public static double shannonEntropy(double[] p)

shannonEntropyBit

public static double shannonEntropyBit(double[] p)

shannonEntropyNat

public static double shannonEntropyNat(double[] p)

shannonEntropyDit

public static double shannonEntropyDit(double[] p)

binaryShannonEntropy

public static double binaryShannonEntropy(double p)

binaryShannonEntropyBit

public static double binaryShannonEntropyBit(double p)

binaryShannonEntropyNat

public static double binaryShannonEntropyNat(double p)

binaryShannonEntropyDit

public static double binaryShannonEntropyDit(double p)

renyiEntropy

public static double renyiEntropy(double[] p,
                                  double alpha)

renyiEntropyNat

public static double renyiEntropyNat(double[] p,
                                     double alpha)

renyiEntropyDit

public static double renyiEntropyDit(double[] p,
                                     double alpha)

renyiEntropyBit

public static double renyiEntropyBit(double[] p,
                                     double alpha)

tsallisEntropyNat

public static double tsallisEntropyNat(double[] p,
                                       double q)

generalizedEntropyOneNat

public static double generalizedEntropyOneNat(double[] p,
                                              double q,
                                              double r)

generalisedEntropyOneNat

public static double generalisedEntropyOneNat(double[] p,
                                              double q,
                                              double r)

histogramBins

public static double[][] histogramBins(double[] data,
                                       double binWidth,
                                       double binZero,
                                       double binUpper)

histogramBins

public static double[][] histogramBins(double[] data,
                                       double binWidth,
                                       double binZero)

histogramBins

public static double[][] histogramBins(double[] data,
                                       double binWidth)

histogramBinsPlot

public static double[][] histogramBinsPlot(double[] data,
                                           double binWidth,
                                           double binZero,
                                           double binUpper)

histogramBinsPlot

public static double[][] histogramBinsPlot(double[] data,
                                           double binWidth,
                                           double binZero,
                                           double binUpper,
                                           java.lang.String xLegend)

histogramBinsPlot

public static double[][] histogramBinsPlot(double[] data,
                                           double binWidth,
                                           double binZero)

histogramBinsPlot

public static double[][] histogramBinsPlot(double[] data,
                                           double binWidth,
                                           double binZero,
                                           java.lang.String xLegend)

histogramBinsPlot

public static double[][] histogramBinsPlot(double[] data,
                                           double binWidth)

histogramBinsPlot

public static double[][] histogramBinsPlot(double[] data,
                                           double binWidth,
                                           java.lang.String xLegend)

uniformOrderStatisticMedians

public static double[] uniformOrderStatisticMedians(int n)

gammaCDF

public static double gammaCDF(double mu,
                              double beta,
                              double gamma,
                              double upperLimit)

gammaCDF

public static double gammaCDF(double gamma,
                              double upperLimit)

gammaPDF

public static double gammaPDF(double mu,
                              double beta,
                              double gamma,
                              double x)

gammaPDF

public static double gammaPDF(double gamma,
                              double x)

gammaMean

public static double gammaMean(double mu,
                               double beta,
                               double gamma)

gammaMode

public static double gammaMode(double mu,
                               double beta,
                               double gamma)

gammaStandardDeviation

public static double gammaStandardDeviation(double mu,
                                            double beta,
                                            double gamma)

gammaStandDev

public static double gammaStandDev(double mu,
                                   double beta,
                                   double gamma)

gammaRand

public static double[] gammaRand(double mu,
                                 double beta,
                                 double gamma,
                                 int n)

gammaRand

public static double[] gammaRand(double mu,
                                 double beta,
                                 double gamma,
                                 int n,
                                 long seed)

gammaFunction

public static double gammaFunction(double x)

gamma
```
public static double gamma(double x)
```

getLanczosGamma

public static double getLanczosGamma()

getLanczosN
```
public static int getLanczosN()
```

getLanczosCoeff

public static double[] getLanczosCoeff()

getFpmin
```
public static double getFpmin()
```

logGammaFunction

public static double logGammaFunction(double x)

logGamma

public static double logGamma(double x)

inverseGammaFunction

public static double[] inverseGammaFunction(double gamma)

gammaFunctionMinimum

public static double[] gammaFunctionMinimum()

regularisedGammaFunction

public static double regularisedGammaFunction(double a,
                                              double x)

regularizedGammaFunction

public static double regularizedGammaFunction(double a,
                                              double x)

regIncompleteGamma

public static double regIncompleteGamma(double a,
                                        double x)

incompleteGamma

public static double incompleteGamma(double a,
                                     double x)

complementaryRegularisedGammaFunction

public static double complementaryRegularisedGammaFunction(double a,
                                                           double x)

complementaryRegularizedGammaFunction

public static double complementaryRegularizedGammaFunction(double a,
                                                           double x)

incompleteGammaComplementary

public static double incompleteGammaComplementary(double a,
                                                  double x)

regIncompleteGammaComplementary

public static double regIncompleteGammaComplementary(double a,
                                                     double x)

incompleteGammaSer

public static double incompleteGammaSer(double a,
                                        double x)

incompleteGammaFract

public static double incompleteGammaFract(double a,
                                          double x)

igSupress
```
public static void igSupress()
```

setIncGammaMaxIter

public static void setIncGammaMaxIter(int igfiter)

getIncGammaMaxIter

public static int getIncGammaMaxIter()

setIncGammaTol

public static void setIncGammaTol(double igfeps)

getIncGammaTol
```
public static double getIncGammaTol()
```

factorial
```
public static int factorial(int n)
```

factorial
```
public static long factorial(long n)
```

factorial

public static java.math.BigInteger factorial(java.math.BigInteger n)

factorial

public static double factorial(double n)

factorial

public static java.math.BigDecimal factorial(java.math.BigDecimal n)

logFactorial

public static double logFactorial(int n)

logFactorial

public static double logFactorial(long n)

logFactorial

public static double logFactorial(double n)

erlangCDF

public static double erlangCDF(double lambda,
                               int kay,
                               double upperLimit)

erlangCDF

public static double erlangCDF(double lambda,
                               long kay,
                               double upperLimit)

erlangCDF

public static double erlangCDF(double lambda,
                               double kay,
                               double upperLimit)

erlangPDF

public static double erlangPDF(double lambda,
                               int kay,
                               double x)

erlangPDF

public static double erlangPDF(double lambda,
                               long kay,
                               double x)

erlangPDF

public static double erlangPDF(double lambda,
                               double kay,
                               double x)

erlangMean

public static double erlangMean(double lambda,
                                int kay)

erlangMean

public static double erlangMean(double lambda,
                                long kay)

erlangMean

public static double erlangMean(double lambda,
                                double kay)

erlangMode

public static double erlangMode(double lambda,
                                int kay)

erlangMode

public static double erlangMode(double lambda,
                                long kay)

erlangMode

public static double erlangMode(double lambda,
                                double kay)

erlangStandardDeviation

public static double erlangStandardDeviation(double lambda,
                                             int kay)

erlangStandardDeviation

public static double erlangStandardDeviation(double lambda,
                                             long kay)

erlangStandardDeviation

public static double erlangStandardDeviation(double lambda,
                                             double kay)

erlangStandDev

public static double erlangStandDev(double lambda,
                                    int kay)

erlangStandDev

public static double erlangStandDev(double lambda,
                                    long kay)

erlangStandDev

public static double erlangStandDev(double lambda,
                                    double kay)

erlangRand

public static double[] erlangRand(double lambda,
                                  int kay,
                                  int n)

erlangRand

public static double[] erlangRand(double lambda,
                                  long kay,
                                  int n)

erlangRand

public static double[] erlangRand(double lambda,
                                  double kay,
                                  int n)

erlangRand

public static double[] erlangRand(double lambda,
                                  int kay,
                                  int n,
                                  long seed)

erlangRand

public static double[] erlangRand(double lambda,
                                  long kay,
                                  int n,
                                  long seed)

erlangRand

public static double[] erlangRand(double lambda,
                                  double kay,
                                  int n,
                                  long seed)

erlangMprobability

public static double erlangMprobability(double totalTraffic,
                                        double totalResources,
                                        double em)

erlangMprobability

public static double erlangMprobability(double totalTraffic,
                                        long totalResources,
                                        long em)

erlangMprobability

public static double erlangMprobability(double totalTraffic,
                                        int totalResources,
                                        int em)

erlangBprobability

public static double erlangBprobability(double totalTraffic,
                                        double totalResources)

erlangBprobability

public static double erlangBprobability(double totalTraffic,
                                        long totalResources)

erlangBprobability

public static double erlangBprobability(double totalTraffic,
                                        int totalResources)

erlangBprobabilityNIR

public static double erlangBprobabilityNIR(double totalTraffic,
                                           double totalResources)

erlangBprobabilityNonIntRes

public static double erlangBprobabilityNonIntRes(double totalTraffic,
                                                 double totalResources)

erlangBload

public static double erlangBload(double blockingProbability,
                                 double totalResources)

erlangBload

public static double erlangBload(double blockingProbability,
                                 long totalResources)

erlangBload

public static double erlangBload(double blockingProbability,
                                 int totalResources)

erlangBresources

public static double[] erlangBresources(double blockingProbability,
                                        double totalTraffic)

erlangCprobability

public static double erlangCprobability(double totalTraffic,
                                        double totalResources)

erlangCprobability

public static double erlangCprobability(double totalTraffic,
                                        long totalResources)

erlangCprobability

public static double erlangCprobability(double totalTraffic,
                                        int totalResources)

erlangCload

public static double erlangCload(double nonZeroDelayProbability,
                                 double totalResources)

erlangCload

public static double erlangCload(double nonZeroDelayProbability,
                                 long totalResources)

erlangCload

public static double erlangCload(double nonZeroDelayProbability,
                                 int totalResources)

erlangCresources

public static double[] erlangCresources(double nonZeroDelayProbability,
                                        double totalTraffic)

engsetProbability

public static double engsetProbability(double offeredTraffic,
                                       double totalResources,
                                       double numberOfSources)

engsetProbability

public static double engsetProbability(double offeredTraffic,
                                       long totalResources,
                                       long numberOfSources)

engsetProbability

public static double engsetProbability(double offeredTraffic,
                                       int totalResources,
                                       int numberOfSources)

engsetLoad

public static double engsetLoad(double blockingProbability,
                                double totalResources,
                                double numberOfSources)

engsetLoad

public static double engsetLoad(double blockingProbability,
                                long totalResources,
                                long numberOfSources)

engsetLoad

public static double engsetLoad(double blockingProbability,
                                int totalResources,
                                int numberOfSources)

engsetResources

public static double[] engsetResources(double blockingProbability,
                                       double offeredTraffic,
                                       double numberOfSources)

engsetResources

public static double[] engsetResources(double blockingProbability,
                                       double totalTraffic,
                                       long numberOfSources)

engsetResources

public static double[] engsetResources(double blockingProbability,
                                       double totalTraffic,
                                       int numberOfSources)

engsetSources

public static double[] engsetSources(double blockingProbability,
                                     double offeredTraffic,
                                     double resources)

engsetSources

public static double[] engsetSources(double blockingProbability,
                                     double totalTraffic,
                                     long resources)

engsetSources

public static double[] engsetSources(double blockingProbability,
                                     double totalTraffic,
                                     int resources)

betaCDF

public static double betaCDF(double alpha,
                             double beta,
                             double limit)

betaCDF

public static double betaCDF(double min,
                             double max,
                             double alpha,
                             double beta,
                             double limit)

betaPDF

public static double betaPDF(double alpha,
                             double beta,
                             double x)

betaPDF

public static double betaPDF(double min,
                             double max,
                             double alpha,
                             double beta,
                             double x)

betaRand

public static double[] betaRand(double alpha,
                                double beta,
                                int n)

betaRand

public static double[] betaRand(double min,
                                double max,
                                double alpha,
                                double beta,
                                int n)

betaRand

public static double[] betaRand(double alpha,
                                double beta,
                                int n,
                                long seed)

betaRand

public static double[] betaRand(double min,
                                double max,
                                double alpha,
                                double beta,
                                int n,
                                long seed)

betaMean

public static double betaMean(double alpha,
                              double beta)

betaMean

public static double betaMean(double min,
                              double max,
                              double alpha,
                              double beta)

betaMode

public static double betaMode(double alpha,
                              double beta)

betaMode

public static double betaMode(double min,
                              double max,
                              double alpha,
                              double beta)

betaStandardDeviation

public static double betaStandardDeviation(double alpha,
                                           double beta)

betaStandDev

public static double betaStandDev(double alpha,
                                  double beta)

betaStandardDeviation

public static double betaStandardDeviation(double min,
                                           double max,
                                           double alpha,
                                           double beta)

betaStandDev

public static double betaStandDev(double min,
                                  double max,
                                  double alpha,
                                  double beta)

betaFunction

public static double betaFunction(double z,
                                  double w)

beta

public static double beta(double z,
                          double w)

regularisedBetaFunction

public static double regularisedBetaFunction(double z,
                                             double w,
                                             double x)

regularizedBetaFunction

public static double regularizedBetaFunction(double z,
                                             double w,
                                             double x)

incompleteBeta

public static double incompleteBeta(double z,
                                    double w,
                                    double x)

contFract

public static double contFract(double a,
                               double b,
                               double x)

resetCFmaxIter

public static void resetCFmaxIter(int cfMaxIter)

getCFmaxIter
```
public static int getCFmaxIter()
```

resetCFtolerance

public static void resetCFtolerance(double cfTol)

getCFtolerance
```
public static double getCFtolerance()
```

erf
```
public static double erf(double x)
```

erfc
```
public static double erfc(double x)
```

normalCDF

public static double normalCDF(double mean,
                               double sd,
                               double upperlimit)

normalProb

public static double normalProb(double mean,
                                double sd,
                                double upperlimit)

gaussianCDF

public static double gaussianCDF(double mean,
                                 double sd,
                                 double upperlimit)

gaussianProb

public static double gaussianProb(double mean,
                                  double sd,
                                  double upperlimit)

normalCDF

public static double normalCDF(double mean,
                               double sd,
                               double lowerlimit,
                               double upperlimit)

normalProb

public static double normalProb(double mean,
                                double sd,
                                double lowerlimit,
                                double upperlimit)

gaussianCDF

public static double gaussianCDF(double mean,
                                 double sd,
                                 double lowerlimit,
                                 double upperlimit)

gaussianProb

public static double gaussianProb(double mean,
                                  double sd,
                                  double lowerlimit,
                                  double upperlimit)

gaussianInverseCDF

public static double gaussianInverseCDF(double mean,
                                        double sd,
                                        double prob)

inverseGaussianCDF

public static double inverseGaussianCDF(double mean,
                                        double sd,
                                        double prob)

normalInverseCDF

public static double normalInverseCDF(double mean,
                                      double sd,
                                      double prob)

inverseNormalCDF

public static double inverseNormalCDF(double mean,
                                      double sd,
                                      double prob)

gaussianInverseCDF

public static double gaussianInverseCDF(double prob)

inverseGaussianCDF

public static double inverseGaussianCDF(double prob)

normalInverseCDF

public static double normalInverseCDF(double prob)

inverseNormalCDF

public static double inverseNormalCDF(double prob)

meanConfidenceLimits

public static double[] meanConfidenceLimits(double mean,
                                            double sd,
                                            double prob)

meanConfidenceLimits

public double[] meanConfidenceLimits(double prob)

gaussianOrderStatisticMedians

public static double[] gaussianOrderStatisticMedians(double mean,
                                                     double sigma,
                                                     int n)

normalOrderStatisticMedians

public static double[] normalOrderStatisticMedians(double mean,
                                                   double sigma,
                                                   int n)

gaussianOrderStatisticMedians

public static double[] gaussianOrderStatisticMedians(int n)

normalOrderStatisticMedians

public static double[] normalOrderStatisticMedians(int n)

normalPDF

public static double normalPDF(double mean,
                               double sd,
                               double x)

normal

public static double normal(double mean,
                            double sd,
                            double x)

gaussianPDF

public static double gaussianPDF(double mean,
                                 double sd,
                                 double x)

gaussian

public static double gaussian(double mean,
                              double sd,
                              double x)

normalRand

public static double[] normalRand(double mean,
                                  double sd,
                                  int n)

gaussianRand

public static double[] gaussianRand(double mean,
                                    double sd,
                                    int n)

normalRand

public static double[] normalRand(double mean,
                                  double sd,
                                  int n,
                                  long seed)

gaussianRand

public static double[] gaussianRand(double mean,
                                    double sd,
                                    int n,
                                    long seed)

logNormalCDF

public static double logNormalCDF(double mu,
                                  double sigma,
                                  double upperLimit)

logNormalTwoParCDF

public static double logNormalTwoParCDF(double mu,
                                        double sigma,
                                        double upperLimit)

logNormalCDF

public static double logNormalCDF(double mu,
                                  double sigma,
                                  double lowerLimit,
                                  double upperLimit)

logNormalTwoParCDF

public static double logNormalTwoParCDF(double mu,
                                        double sigma,
                                        double lowerLimit,
                                        double upperLimit)

logNormalInverseCDF

public static double logNormalInverseCDF(double mu,
                                         double sigma,
                                         double prob)

logNormaltwoParInverseCDF

public static double logNormaltwoParInverseCDF(double mu,
                                               double sigma,
                                               double prob)

logNormalPDF

public static double logNormalPDF(double mu,
                                  double sigma,
                                  double x)

logNormalTwoParPDF

public static double logNormalTwoParPDF(double mu,
                                        double sigma,
                                        double x)

logNormalMean

public static double logNormalMean(double mu,
                                   double sigma)

logNormalTwoParMean

public static double logNormalTwoParMean(double mu,
                                         double sigma)

logNormalStandardDeviation

public static double logNormalStandardDeviation(double mu,
                                                double sigma)

logNormalStandDev

public static double logNormalStandDev(double mu,
                                       double sigma)

logNormalTwoParStandardDeviation

public static double logNormalTwoParStandardDeviation(double mu,
                                                      double sigma)

logNormalTwoParStandDev

public static double logNormalTwoParStandDev(double mu,
                                             double sigma)

logNormalMode

public static double logNormalMode(double mu,
                                   double sigma)

logNormalTwoParMode

public static double logNormalTwoParMode(double mu,
                                         double sigma)

logNormalMedian

public static double logNormalMedian(double mu)

logNormalTwoParMedian

public static double logNormalTwoParMedian(double mu)

logNormalRand

public static double[] logNormalRand(double mu,
                                     double sigma,
                                     int n)

logNormalTwoParRand

public static double[] logNormalTwoParRand(double mu,
                                           double sigma,
                                           int n)

logNormalOrderStatisticMedians

public static double[] logNormalOrderStatisticMedians(double mu,
                                                      double sigma,
                                                      int n)

logNormalTwoParOrderStatisticMedians

public static double[] logNormalTwoParOrderStatisticMedians(double mu,
                                                            double sigma,
                                                            int n)

logNormalRand

public static double[] logNormalRand(double mu,
                                     double sigma,
                                     int n,
                                     long seed)

logNormalTwoParRand

public static double[] logNormalTwoParRand(double mu,
                                           double sigma,
                                           int n,
                                           long seed)

logNormalThreeParCDF

public static double logNormalThreeParCDF(double alpha,
                                          double beta,
                                          double gamma,
                                          double upperLimit)

logNormalThreeParCDF

public static double logNormalThreeParCDF(double alpha,
                                          double beta,
                                          double gamma,
                                          double lowerLimit,
                                          double upperLimit)

logNormalInverseCDF

public static double logNormalInverseCDF(double alpha,
                                         double beta,
                                         double gamma,
                                         double prob)

logNormalThreeParInverseCDF

public static double logNormalThreeParInverseCDF(double alpha,
                                                 double beta,
                                                 double gamma,
                                                 double prob)

logNormalThreeParPDF

public static double logNormalThreeParPDF(double alpha,
                                          double beta,
                                          double gamma,
                                          double x)

logNormalThreeParRand

public static double[] logNormalThreeParRand(double alpha,
                                             double beta,
                                             double gamma,
                                             int n)

logNormalThreeParRand

public static double[] logNormalThreeParRand(double alpha,
                                             double beta,
                                             double gamma,
                                             int n,
                                             long seed)

logNormalOrderStatisticMedians

public static double[] logNormalOrderStatisticMedians(double alpha,
                                                      double beta,
                                                      double gamma,
                                                      int n)

logNormalThreeParOrderStatisticMedians

public static double[] logNormalThreeParOrderStatisticMedians(double alpha,
                                                              double beta,
                                                              double gamma,
                                                              int n)

logNormalThreeParMean

public static double logNormalThreeParMean(double alpha,
                                           double beta,
                                           double gamma)

logNormalThreeParStandardDeviation

public static double logNormalThreeParStandardDeviation(double alpha,
                                                        double beta,
                                                        double gamma)

logNormalThreeParStandDev

public static double logNormalThreeParStandDev(double alpha,
                                               double beta,
                                               double gamma)

logNormalThreeParMode

public static double logNormalThreeParMode(double alpha,
                                           double beta,
                                           double gamma)

logNormalThreeParMedian

public static double logNormalThreeParMedian(double alpha,
                                             double gamma)

logisticCDF

public static double logisticCDF(double mu,
                                 double beta,
                                 double upperlimit)

logisticTwoParCDF

public static double logisticTwoParCDF(double mu,
                                       double beta,
                                       double upperlimit)

logisticProb

public static double logisticProb(double mu,
                                  double beta,
                                  double upperlimit)

logisticCDF

public static double logisticCDF(double mu,
                                 double beta,
                                 double lowerlimit,
                                 double upperlimit)

logisticTwoParCDF

public static double logisticTwoParCDF(double mu,
                                       double beta,
                                       double lowerlimit,
                                       double upperlimit)

logisticProb

public static double logisticProb(double mu,
                                  double beta,
                                  double lowerlimit,
                                  double upperlimit)

logisticTwoParInverseCDF

public static double logisticTwoParInverseCDF(double mu,
                                              double beta,
                                              double prob)

logisticInverseCDF

public static double logisticInverseCDF(double mu,
                                        double beta,
                                        double prob)

logisticPDF

public static double logisticPDF(double mu,
                                 double beta,
                                 double x)

logisticTwoParPDF

public static double logisticTwoParPDF(double mu,
                                       double beta,
                                       double x)

logistic

public static double logistic(double mu,
                              double beta,
                              double x)

logisticTwoParRand

public static double[] logisticTwoParRand(double mu,
                                          double beta,
                                          int n)

logisticRand

public static double[] logisticRand(double mu,
                                    double beta,
                                    int n)

logisticTwoParRand

public static double[] logisticTwoParRand(double mu,
                                          double beta,
                                          int n,
                                          long seed)

logisticRand

public static double[] logisticRand(double mu,
                                    double beta,
                                    int n,
                                    long seed)

logisticOrderStatisticMedians

public static double[] logisticOrderStatisticMedians(double mu,
                                                     double beta,
                                                     int n)

logisticTwoParOrderStatisticMedians

public static double[] logisticTwoParOrderStatisticMedians(double mu,
                                                           double beta,
                                                           int n)

logisticMean

public static double logisticMean(double mu)

logisticTwoParMean

public static double logisticTwoParMean(double mu)

logisticStandardDeviation

public static double logisticStandardDeviation(double beta)

logisticStandDev

public static double logisticStandDev(double beta)

logisticTwoParStandardDeviation

public static double logisticTwoParStandardDeviation(double beta)

logisticMode

public static double logisticMode(double mu)

logisticTwoParMode

public static double logisticTwoParMode(double mu)

logisticMedian

public static double logisticMedian(double mu)

logisticTwoParMedian

public static double logisticTwoParMedian(double mu)

lorentzianProb

public static double lorentzianProb(double mu,
                                    double gamma,
                                    double upperlimit)

lorentzianCDF

public static double lorentzianCDF(double mu,
                                   double gamma,
                                   double lowerlimit,
                                   double upperlimit)

lorentzianProb

public static double lorentzianProb(double mu,
                                    double gamma,
                                    double lowerlimit,
                                    double upperlimit)

lorentzianInverseCDF

public static double lorentzianInverseCDF(double mu,
                                          double gamma,
                                          double prob)

lorentzianPDF

public static double lorentzianPDF(double mu,
                                   double gamma,
                                   double x)

lorentzian

public static double lorentzian(double mu,
                                double gamma,
                                double x)

lorentzianRand

public static double[] lorentzianRand(double mu,
                                      double gamma,
                                      int n)

lorentzianRand

public static double[] lorentzianRand(double mu,
                                      double gamma,
                                      int n,
                                      long seed)

lorentzianOrderStatisticMedians

public static double[] lorentzianOrderStatisticMedians(double mu,
                                                       double gamma,
                                                       int n)

poissonCDF

public static double poissonCDF(int k,
                                double mean)

poissonProb

public static double poissonProb(int k,
                                 double mean)

poissonPDF

public static double poissonPDF(int k,
                                double mean)

poisson

public static double poisson(int k,
                             double mean)

poissonRand

public static double[] poissonRand(double mean,
                                   int n)

poissonRand

public static double[] poissonRand(double mean,
                                   int n,
                                   long seed)

chiSquareCDF

public static double chiSquareCDF(double chiSquare,
                                  int nu)

chiSquareProb

public static double chiSquareProb(double chiSquare,
                                   int nu)

chiSquareInverseCDF

public static double chiSquareInverseCDF(int nu,
                                         double prob)

inverseChiSquareCDF

public static double inverseChiSquareCDF(int nu,
                                         double prob)

chiSquarePDF

public static double chiSquarePDF(double chiSquare,
                                  int nu)

chiSquareRand

public static double[] chiSquareRand(int nu,
                                     int n)

chiSquareRand

public static double[] chiSquareRand(int nu,
                                     int n,
                                     long seed)

chiSquareMean

public static double chiSquareMean(int nu)

chiSquareMode

public static double chiSquareMode(int nu)

chiSquareStandardDeviation

public static double chiSquareStandardDeviation(int nu)

chiSquareStandDev

public static double chiSquareStandDev(int nu)

chiSquare

public static double chiSquare(double[] observed,
                               double[] expected,
                               double[] variance)

chiSquareFreq

public static double chiSquareFreq(double[] observedFreq,
                                   double[] expectedFreq)

chiSquareFreq

public static double chiSquareFreq(int[] observedFreq,
                                   int[] expectedFreq)

wilsonHilferty

public static double wilsonHilferty(double chiSquare,
                                    int nu)

binomialCDF

public static double binomialCDF(double p,
                                 int n,
                                 int k)

binomialProb

public static double binomialProb(double p,
                                  int n,
                                  int k)

binomialPDF

public static double binomialPDF(double p,
                                 int n,
                                 int k)

binomial

public static double binomial(double p,
                              int n,
                              int k)

binomialCoeff

public static double binomialCoeff(int n,
                                   int k)

binomialRand

public double[] binomialRand(double prob,
                             int nTrials,
                             int n)

binomialRand

public double[] binomialRand(double prob,
                             int nTrials,
                             int n,
                             long seed)

fCompCDF

public static double fCompCDF(double fValue,
                              int df1,
                              int df2)

fTestProb

public static double fTestProb(double fValue,
                               int df1,
                               int df2)

fCompCDF

public static double fCompCDF(double var1,
                              int df1,
                              double var2,
                              int df2)

fTestProb

public static double fTestProb(double var1,
                               int df1,
                               double var2,
                               int df2)

fDistributionInverseCDF

public static double fDistributionInverseCDF(int nu1,
                                             int nu2,
                                             double prob)

fDistributionOrderStatisticMedians

public static double[] fDistributionOrderStatisticMedians(int nu1,
                                                          int nu2,
                                                          int n)

fTestValueGivenFprob

public static double fTestValueGivenFprob(double fProb,
                                          int df1,
                                          int df2)

fPDF

public double fPDF(double fValue,
                   int nu1,
                   int nu2)

fPDF

public double fPDF(double var1,
                   int nu1,
                   double var2,
                   int nu2)

fRand

public static double[] fRand(int nu1,
                             int nu2,
                             int n)

fRand

public static double[] fRand(int nu1,
                             int nu2,
                             int n,
                             long seed)

studentst

public static double studentst(double tValue,
                               int df)

studentT

public static double studentT(double tValue,
                              int df)

studentstPDF

public static double studentstPDF(double tValue,
                                  int df)

studentTpdf

public static double studentTpdf(double tValue,
                                 int df)

studentTPDF

public static double studentTPDF(double tValue,
                                 int df)

studentstCDF

public static double studentstCDF(double tValue,
                                  int df)

studentTProb

public static double studentTProb(double tValue,
                                  int df)

studentTcdf

public static double studentTcdf(double tValue,
                                 int df)

studentTCDF

public static double studentTCDF(double tValue,
                                 int df)

studentTcdf

public static double studentTcdf(double tValueLower,
                                 double tValueUpper,
                                 int df)

pValue

public static double pValue(double tValue,
                            int df)

studentstMean

public static double studentstMean(int df)

studentTmean

public static double studentTmean(int df)

studentstMedian

public static double studentstMedian()

studentTmedian
```
public static double studentTmedian()
```

studentstMode
```
public static double studentstMode()
```

studentTmode
```
public static double studentTmode()
```

studentstStandardDeviation

public static double studentstStandardDeviation(int df)

studentTstandDev

public static double studentTstandDev(int df)

probAtn

public static double probAtn(double tValue,
                             int df)

studentstRand

public static double[] studentstRand(int nu,
                                     int n)

studentTRand

public static double[] studentTRand(int nu,
                                    int n)

studentTrand

public static double[] studentTrand(int nu,
                                    int n)

studentstRand

public static double[] studentstRand(int nu,
                                     int n,
                                     long seed)

studentTrand

public static double[] studentTrand(int nu,
                                    int n,
                                    long seed)

studentTRand

public static double[] studentTRand(int nu,
                                    int n,
                                    long seed)

gumbelMinProbCDF

public static double gumbelMinProbCDF(double mu,
                                      double sigma,
                                      double upperlimit)

gumbelMinProb

public static double gumbelMinProb(double mu,
                                   double sigma,
                                   double upperlimit)

gumbelMaxCDF

public static double gumbelMaxCDF(double mu,
                                  double sigma,
                                  double upperlimit)

gumbelMaxProb

public static double gumbelMaxProb(double mu,
                                   double sigma,
                                   double upperlimit)

gumbelMaxInverseCDF

public static double gumbelMaxInverseCDF(double mu,
                                         double sigma,
                                         double prob)

gumbelMinCDF

public static double gumbelMinCDF(double mu,
                                  double sigma,
                                  double lowerlimit,
                                  double upperlimit)

gumbelMinProb

public static double gumbelMinProb(double mu,
                                   double sigma,
                                   double lowerlimit,
                                   double upperlimit)

gumbelMaxCDF

public static double gumbelMaxCDF(double mu,
                                  double sigma,
                                  double lowerlimit,
                                  double upperlimit)

gumbelMaxProb

public static double gumbelMaxProb(double mu,
                                   double sigma,
                                   double lowerlimit,
                                   double upperlimit)

gumbelMinInverseCDF

public static double gumbelMinInverseCDF(double mu,
                                         double sigma,
                                         double prob)

gumbelMinPDF

public static double gumbelMinPDF(double mu,
                                  double sigma,
                                  double x)

gumbelMin

public static double gumbelMin(double mu,
                               double sigma,
                               double x)

gumbelMaxPDF

public static double gumbelMaxPDF(double mu,
                                  double sigma,
                                  double x)

gumbelMax

public static double gumbelMax(double mu,
                               double sigma,
                               double x)

gumbelMinRand

public static double[] gumbelMinRand(double mu,
                                     double sigma,
                                     int n)

gumbelMinRand

public static double[] gumbelMinRand(double mu,
                                     double sigma,
                                     int n,
                                     long seed)

gumbelMaxRand

public static double[] gumbelMaxRand(double mu,
                                     double sigma,
                                     int n)

gumbelMaxRand

public static double[] gumbelMaxRand(double mu,
                                     double sigma,
                                     int n,
                                     long seed)

gumbelMinOrderStatisticMedians

public static double[] gumbelMinOrderStatisticMedians(double mu,
                                                      double sigma,
                                                      int n)

gumbelMaxOrderStatisticMedians

public static double[] gumbelMaxOrderStatisticMedians(double mu,
                                                      double sigma,
                                                      int n)

gumbelMinMean

public static double gumbelMinMean(double mu,
                                   double sigma)

gumbelMaxMean

public static double gumbelMaxMean(double mu,
                                   double sigma)

gumbelMinStandardDeviation

public static double gumbelMinStandardDeviation(double sigma)

gumbelMinStandDev

public static double gumbelMinStandDev(double sigma)

gumbelMaxStandardDeviation

public static double gumbelMaxStandardDeviation(double sigma)

gumbelMaxStandDev

public static double gumbelMaxStandDev(double sigma)

gumbelMinMode

public static double gumbelMinMode(double mu,
                                   double sigma)

gumbelMaxMode

public static double gumbelMaxMode(double mu,
                                   double sigma)

gumbelMinMedian

public static double gumbelMinMedian(double mu,
                                     double sigma)

gumbelMaxMedian

public static double gumbelMaxMedian(double mu,
                                     double sigma)

frechetProb

public static double frechetProb(double mu,
                                 double sigma,
                                 double gamma,
                                 double upperlimit)

frechetCDF

public static double frechetCDF(double mu,
                                double sigma,
                                double gamma,
                                double lowerlimit,
                                double upperlimit)

frechetProb

public static double frechetProb(double mu,
                                 double sigma,
                                 double gamma,
                                 double lowerlimit,
                                 double upperlimit)

frechetInverseCDF

public static double frechetInverseCDF(double mu,
                                       double sigma,
                                       double gamma,
                                       double prob)

frechetInverseCDF

public static double frechetInverseCDF(double sigma,
                                       double gamma,
                                       double prob)

frechetInverseCDF

public static double frechetInverseCDF(double gamma,
                                       double prob)

frechetPDF

public static double frechetPDF(double mu,
                                double sigma,
                                double gamma,
                                double x)

frechet

public static double frechet(double mu,
                             double sigma,
                             double gamma,
                             double x)

frechetOrderStatisticMedians

public static double[] frechetOrderStatisticMedians(double mu,
                                                    double sigma,
                                                    double gamma,
                                                    int n)

frechetOrderStatisticMedians

public static double[] frechetOrderStatisticMedians(double sigma,
                                                    double gamma,
                                                    int n)

frechetOrderStatisticMedians

public static double[] frechetOrderStatisticMedians(double gamma,
                                                    int n)

frechetMean

public static double frechetMean(double mu,
                                 double sigma,
                                 double gamma)

frechetStandardDeviation

public static double frechetStandardDeviation(double sigma,
                                              double gamma)

frechetStandDev

public static double frechetStandDev(double sigma,
                                     double gamma)

frechetMode

public static double frechetMode(double mu,
                                 double sigma,
                                 double gamma)

frechetRand

public static double[] frechetRand(double mu,
                                   double sigma,
                                   double gamma,
                                   int n)

frechetRand

public static double[] frechetRand(double mu,
                                   double sigma,
                                   double gamma,
                                   int n,
                                   long seed)

weibullCDF

public static double weibullCDF(double mu,
                                double sigma,
                                double gamma,
                                double upperlimit)

weibullProb

public static double weibullProb(double mu,
                                 double sigma,
                                 double gamma,
                                 double upperlimit)

weibullCDF

public static double weibullCDF(double mu,
                                double sigma,
                                double gamma,
                                double lowerlimit,
                                double upperlimit)

weibullProb

public static double weibullProb(double mu,
                                 double sigma,
                                 double gamma,
                                 double lowerlimit,
                                 double upperlimit)

weibullInverseCDF

public static double weibullInverseCDF(double mu,
                                       double sigma,
                                       double gamma,
                                       double prob)

inverseWeibullCDF

public static double inverseWeibullCDF(double mu,
                                       double sigma,
                                       double gamma,
                                       double prob)

weibullInverseCDF

public static double weibullInverseCDF(double sigma,
                                       double gamma,
                                       double prob)

inverseWeibullCDF

public static double inverseWeibullCDF(double sigma,
                                       double gamma,
                                       double prob)

weibullInverseCDF

public static double weibullInverseCDF(double gamma,
                                       double prob)

inverseWeibullCDF

public static double inverseWeibullCDF(double gamma,
                                       double prob)

weibullPDF

public static double weibullPDF(double mu,
                                double sigma,
                                double gamma,
                                double x)

weibull

public static double weibull(double mu,
                             double sigma,
                             double gamma,
                             double x)

weibullMean

public static double weibullMean(double mu,
                                 double sigma,
                                 double gamma)

weibullStandardDeviation

public static double weibullStandardDeviation(double sigma,
                                              double gamma)

weibullStandDev

public static double weibullStandDev(double sigma,
                                     double gamma)

weibullMode

public static double weibullMode(double mu,
                                 double sigma,
                                 double gamma)

weibullMedian

public static double weibullMedian(double mu,
                                   double sigma,
                                   double gamma)

weibullRand

public static double[] weibullRand(double mu,
                                   double sigma,
                                   double gamma,
                                   int n)

weibullRand

public static double[] weibullRand(double mu,
                                   double sigma,
                                   double gamma,
                                   int n,
                                   long seed)

weibullOrderStatisticMedians

public static double[] weibullOrderStatisticMedians(double mu,
                                                    double sigma,
                                                    double gamma,
                                                    int n)

weibullOrderStatisticMedians

public static double[] weibullOrderStatisticMedians(double sigma,
                                                    double gamma,
                                                    int n)

weibullOrderStatisticMedians

public static double[] weibullOrderStatisticMedians(double gamma,
                                                    int n)

exponentialCDF

public static double exponentialCDF(double mu,
                                    double sigma,
                                    double upperlimit)

exponentialProb

public static double exponentialProb(double mu,
                                     double sigma,
                                     double upperlimit)

exponentialCDF

public static double exponentialCDF(double mu,
                                    double sigma,
                                    double lowerlimit,
                                    double upperlimit)

exponentialProb

public static double exponentialProb(double mu,
                                     double sigma,
                                     double lowerlimit,
                                     double upperlimit)

exponentialInverseCDF

public static double exponentialInverseCDF(double mu,
                                           double sigma,
                                           double prob)

inverseExponentialCDF

public static double inverseExponentialCDF(double mu,
                                           double sigma,
                                           double prob)

exponentialPDF

public static double exponentialPDF(double mu,
                                    double sigma,
                                    double x)

exponential

public static double exponential(double mu,
                                 double sigma,
                                 double x)

exponentialMean

public static double exponentialMean(double mu,
                                     double sigma)

exponentialStandardDeviation

public static double exponentialStandardDeviation(double sigma)

exponentialStandDev

public static double exponentialStandDev(double sigma)

exponentialMode

public static double exponentialMode(double mu)

exponentialMedian

public static double exponentialMedian(double mu,
                                       double sigma)

exponentialRand

public static double[] exponentialRand(double mu,
                                       double sigma,
                                       int n)

exponentialRand

public static double[] exponentialRand(double mu,
                                       double sigma,
                                       int n,
                                       long seed)

exponentialOrderStatisticMedians

public static double[] exponentialOrderStatisticMedians(double mu,
                                                        double sigma,
                                                        int n)

rayleighCDF

public static double rayleighCDF(double beta,
                                 double upperlimit)

rayleighProb

public static double rayleighProb(double beta,
                                  double upperlimit)

rayleighCDF

public static double rayleighCDF(double beta,
                                 double lowerlimit,
                                 double upperlimit)

rayleighProb

public static double rayleighProb(double beta,
                                  double lowerlimit,
                                  double upperlimit)

rayleighInverseCDF

public static double rayleighInverseCDF(double beta,
                                        double prob)

inverseRayleighCDF

public static double inverseRayleighCDF(double beta,
                                        double prob)

rayleighPDF

public static double rayleighPDF(double beta,
                                 double x)

rayleigh

public static double rayleigh(double beta,
                              double x)

rayleighMean

public static double rayleighMean(double beta)

rayleighStandardDeviation

public static double rayleighStandardDeviation(double beta)

rayleighStandDev

public static double rayleighStandDev(double beta)

rayleighMode

public static double rayleighMode(double beta)

rayleighMedian

public static double rayleighMedian(double beta)

rayleighRand

public static double[] rayleighRand(double beta,
                                    int n)

rayleighRand

public static double[] rayleighRand(double beta,
                                    int n,
                                    long seed)

rayleighOrderStatisticMedians

public static double[] rayleighOrderStatisticMedians(double beta,
                                                     int n)

paretoCDF

public static double paretoCDF(double alpha,
                               double beta,
                               double upperlimit)

paretoProb

public static double paretoProb(double alpha,
                                double beta,
                                double upperlimit)

paretoCDF

public static double paretoCDF(double alpha,
                               double beta,
                               double lowerlimit,
                               double upperlimit)

paretoProb

public static double paretoProb(double alpha,
                                double beta,
                                double lowerlimit,
                                double upperlimit)

paretoInverseCDF

public static double paretoInverseCDF(double alpha,
                                      double beta,
                                      double prob)

inverseParetoCDF

public static double inverseParetoCDF(double alpha,
                                      double beta,
                                      double prob)

paretoPDF

public static double paretoPDF(double alpha,
                               double beta,
                               double x)

pareto

public static double pareto(double alpha,
                            double beta,
                            double x)

paretoMean

public static double paretoMean(double alpha,
                                double beta)

paretoStandardDeviation

public static double paretoStandardDeviation(double alpha,
                                             double beta)

paretoStandDev

public static double paretoStandDev(double alpha,
                                    double beta)

paretoMode

public static double paretoMode(double beta)

paretoRand

public static double[] paretoRand(double alpha,
                                  double beta,
                                  int n)

paretoRand

public static double[] paretoRand(double alpha,
                                  double beta,
                                  int n,
                                  long seed)

paretoOrderStatisticMedians

public static double[] paretoOrderStatisticMedians(double alpha,
                                                   double beta,
                                                   int n)

fitOneOrSeveralDistributions

public void fitOneOrSeveralDistributions()

fitOneOrSeveralDistributions

public static void fitOneOrSeveralDistributions(double[] array)

upperOutliersAnscombeAsVector

public static java.util.Vector<java.lang.Object> upperOutliersAnscombeAsVector(double[] values,
                                                                               double constant)

upperOutliersAnscombe

public static java.util.Vector<java.lang.Object> upperOutliersAnscombe(double[] values,
                                                                       double constant)

upperOutliersAnscombeAsArrayList

public static java.util.ArrayList<java.lang.Object> upperOutliersAnscombeAsArrayList(double[] values,
                                                                                     double constant)

upperOutliersAnscombeAsVector

public static java.util.Vector<java.lang.Object> upperOutliersAnscombeAsVector(java.math.BigDecimal[] values,
                                                                               java.math.BigDecimal constant)

upperOutliersAnscombe

public static java.util.Vector<java.lang.Object> upperOutliersAnscombe(java.math.BigDecimal[] values,
                                                                       java.math.BigDecimal constant)

upperOutliersAnscombeAsArrayList

public static java.util.ArrayList<java.lang.Object> upperOutliersAnscombeAsArrayList(java.math.BigDecimal[] values,
                                                                                     java.math.BigDecimal constant)

upperOutliersAnscombeAsVector

public static java.util.Vector<java.lang.Object> upperOutliersAnscombeAsVector(java.math.BigInteger[] values,
                                                                               java.math.BigInteger constant)

upperOutliersAnscombe

public static java.util.Vector<java.lang.Object> upperOutliersAnscombe(java.math.BigInteger[] values,
                                                                       java.math.BigInteger constant)

upperOutliersAnscombeAsArrayList

public static java.util.ArrayList<java.lang.Object> upperOutliersAnscombeAsArrayList(java.math.BigInteger[] values,
                                                                                     java.math.BigInteger constant)

lowerOutliersAnscombeAsVector

public static java.util.Vector<java.lang.Object> lowerOutliersAnscombeAsVector(double[] values,
                                                                               double constant)

lowerOutliersAnscombe

public static java.util.Vector<java.lang.Object> lowerOutliersAnscombe(double[] values,
                                                                       double constant)

lowerOutliersAnscombeAsArrayList

public static java.util.ArrayList<java.lang.Object> lowerOutliersAnscombeAsArrayList(double[] values,
                                                                                     double constant)

lowerOutliersAnscombeAsVector

public static java.util.Vector<java.lang.Object> lowerOutliersAnscombeAsVector(java.math.BigDecimal[] values,
                                                                               java.math.BigDecimal constant)

lowerOutliersAnscombe

public static java.util.Vector<java.lang.Object> lowerOutliersAnscombe(java.math.BigDecimal[] values,
                                                                       java.math.BigDecimal constant)

lowerOutliersAnscombeAsArrayList

public static java.util.ArrayList<java.lang.Object> lowerOutliersAnscombeAsArrayList(java.math.BigDecimal[] values,
                                                                                     java.math.BigDecimal constant)

lowerOutliersAnscombeAsVector

public static java.util.Vector<java.lang.Object> lowerOutliersAnscombeAsVector(java.math.BigInteger[] values,
                                                                               java.math.BigInteger constant)

lowerOutliersAnscombe

public static java.util.Vector<java.lang.Object> lowerOutliersAnscombe(java.math.BigInteger[] values,
                                                                       java.math.BigInteger constant)

lowerOutliersAnscombeAsArrayList

public static java.util.ArrayList<java.lang.Object> lowerOutliersAnscombeAsArrayList(java.math.BigInteger[] values,
                                                                                     java.math.BigInteger constant)

copy
```
public Stat copy()
```
Overrides:

copy in class ArrayMaths

Skip navigation links

All Classes

Summary:
Nested |
Field |
Constr |
Method

Detail:
Field |
Constr |
Method

Class Stat

Field Summary

Fields inherited from class flanagan.math.ArrayMaths

Constructor Summary

Method Summary

Methods inherited from class flanagan.math.ArrayMaths

Methods inherited from class java.lang.Object

Field Detail

FPMIN

Constructor Detail

Stat

Stat

Stat

Stat

Stat

Stat

Stat

Stat

Stat

Stat

Stat

Stat

Stat

Stat

Stat

Stat

Stat

Stat

Stat

Stat

Stat

Method Detail

convertToHighest

setWeightsToBigW

setWeightsToLittleW

setDenominatorToN

setDenominatorToNminusOne

useEffectiveN

useTrueN

effectiveSampleNumber

effectiveSampleNumber_as_double

effectiveSampleNumber_as_BigDecimal

effectiveSampleNumber_as_Complex

trueSampleNumber

trueSampleNumber_as_int

trueSampleNumber_as_double

trueSampleNumber_as_BigDecimal

trueSampleNumber_as_Complex

convertBigWtoLittleW

setWeights

setWeights

setWeights

setWeights

setWeights

setWeights

setWeights

setWeights

setWeights

setWeights

setWeights

setWeights

setWeights

setWeights

setWeights

setWeights

setWeights

setWeights

setWeights

mean

mean_as_double

mean_as_BigDecimal

mean_as_Complex

weightedMean

weightedMean_as_double

weightedMean_as_BigDecimal

weightedMean_as_Complex

subtractMean

subtractMean_as_double

subtractMean_as_BigDecimal

subtractMean_as_Complex