|
|
|
| Constructors | for Vector<Object> | public Stat(Vector<Object> vec) |
| for ArrayList<Object> | public Stat(ArrayList<Object> list) | |
| for double[] array | public Stat(Object[] array) | |
| for double[] array | public Stat(double[] array) | |
| for Double[] array | public Stat(Double[] array) | |
| for float[] array | public Stat(float[] array) | |
| for Float[] array | public Stat(Float[] array) | |
| for long[] array | public Stat(long[] array) | |
| for Long[] array | public Stat(Long[] array) | |
| for int[] array | public Stat(int[] array) | |
| for Integer[] array | public Stat(Integer[] array) | |
| for short[] array | public Stat(short[] array) | |
| for Short[] array | public Stat(Short[] array) | |
| for byte[] array | public Stat(byte[] array) | |
| for Byte[] array | public Stat(Byte[] array) | |
| for BigDecimal[] array | public Stat(BigDecimal[] array) | |
| for BigInteger[] array | public Stat(BigInteger[] array) | |
| for Complex[] array | public Stat(Complex[] array) | |
| for Phasor[] array | public Stat(Phasor[] array) | |
| Enter array of weights | as Vector<Object> | public void setWeights(Vector<Object> vec) |
| as ArrayList<Object> | public void setWeights(ArrayList<Object> list) | |
| as double[] array | public void setWeights(Object[] array) | |
| as double[] array | public void setWeights(double[] array) | |
| as Double[] array | public void setWeights(Double[] array) | |
| as float[] array | public void setWeights(float[] array) | |
| as Float[] array | public void setWeights(Float[] array) | |
| as long[] array | public void setWeights(long[] array) | |
| as Long[] array | public void setWeights(Long[] array) | |
| as int[] array | public void setWeights(int[] array) | |
| as Integer[] array | public void setWeights(Integer[] array) | |
| as short[] array | public void setWeights(short[] array) | |
| as Short[] array | public void setWeights(Short[] array) | |
| as byte[] array | public void setWeights(byte[] array) | |
| as Byte[] array | public void setWeights(Byte[] array) | |
| as BigDecimal[] array | public void setWeights(BigDecimal[] array) | |
| as BigInteger[] array | public void setWeights(BigInteger[] array) | |
| as Complex[] array | public void setWeights(Complex[] array) | |
| as Phasor[] array | public void setWeights(Phasor[] array) | |
|
Weighting Factor Options | Instance methods | public void setWeightsToBigW() |
| public void setWeightsToLittleW() | ||
| public void convertBigWtoLittleW() [deprecated] | ||
| Static methods | public void setStaticWeightsToBigW() | |
| public void setStaticWeightsToLittleW() | ||
| public double[] convertBigWtoLittleW(double[] bigW) [deprecated] | ||
|
Effective Sample Number Instance methods | Set to n | public void useTrueN() |
| Set to nEff | public void useEffectiveN() | |
|
Effective Sample Number Static methods | Set to n | public double setStaticTrueN() |
| Set to n-1 | public double setStaticEffectiveN() | |
|
Arithmetic Mean Instance methods | Arithmetic Mean | public double mean_as_double() |
| public BigDecimal mean_as_BigDecimal() | ||
| public Complex mean_as_Complex() | ||
| Weighted Arithmetic Mean | public double weightedMean_as_double() | |
| public BigDecimal weightedMean_as_BigDecimal() | ||
| public Complex weightedMean_as_Complex() | ||
| Subtract Arithmetic Mean from the Array | public double subtractMean_as_double() | |
| public BigDecimal subtractMean_as_BigDecimal() | ||
| public Complex subtractMean_as_Complex() | ||
| Subtract Weighted Arithmetic Mean from the Array | public double subtractWeightedMean_as_double() | |
| public BigDecimal subtractWeightMean_as_BigDecimal() | ||
| public Complex subtractWeightedMean_as_Complex() | ||
|
Arithmetic Mean Static methods | Arithmetic Mean | public static double mean(double[] a) |
| public static double mean(float[] a) | ||
| public static BigDecimal mean(BigDecimal[] a) | ||
| public static BigInteger mean(BigInteger[] a) | ||
| public static Complex mean(Complex[] a) | ||
| public static double mean(int[] a) | ||
| public static double mean(long[] a) | ||
| public static double mean(short[] a) | ||
| public static double mean(byte[] a) | ||
| Weighted Arithmetic Mean | public static double mean(double[] a, double[] w) | |
| public static float mean(float[] a, float[] w) | ||
| public static BigDecimal mean(BigDecimal[] a, BigDecimal[] w) | ||
| public static BigInteger mean(BigInteger[] a, BigInteger[] w) | ||
| public static Complex mean(Complex[] a, Complex[] w) | ||
| Subtract the Arithmetic Mean | public static double[] subtractMean(double[] a) | |
| public static float[] subtractMean(float[] a) | ||
| public static BigDecimal[] subtractMean(BigDecimal[] a) | ||
| public static BigDecimal[] subtractMean(BigInteger[] a) | ||
| public static Complex[] subtractMean(Complex[] a) | ||
| Subtract the Weighted Arithmetic Mean | public static double[] subtractMean(double[] a, double[] w) | |
| public static float[] subtractMean(float[] a, float[] w) | ||
| public static BigDecimal[] subtractMean(BigDecimal[] a, BigDecimal[] w) | ||
| public static BigDecimal[] subtractMean(BigInteger[] a, BigInteger[] w) | ||
| public static Complex[] subtractMean(Complex[] a, Complex[] w) | ||
|
Geometric Mean Instance methods | Geometric Mean | public static double geometricMean_as_double() |
| public static Complex geometricMean_as_Complex() | ||
| Weighted Geometric Mean | public static double weightedGeometricMean_as_double() | |
| public static Complex weightedGeometricMean_as_Complex() | ||
|
Geometric Mean Static methods | Geometric Mean | public static double geometricMean(double[] a) |
| public static float geometricMean(float[] a) | ||
| public static Complex geometricMean(Complex[] a) | ||
| public static double geometricMean(BigDecimal[] a) | ||
| public static double geometricMean(BigInteger[] a) | ||
| Weighted Geometric Mean | public static double geometricMean(double[] a, double[] w) | |
| public static float geometricMean(float[] a, float[] w) | ||
| public static Complex geometricMean( Complex[] a, Complex[] w) | ||
| public static double geometricMean(BigDecimal[] a, BigDecimal[] w) | ||
| public static double geometricMean(BigInteger[] a, BigInteger[] w) | ||
|
Harmonic Mean Instance methods | Harmonic Mean | public double harmonicMean_as_double() |
| public Complex harmonicMean_as_Complex() | ||
| public bigDecimal harmonicMean_as_BigDecimal() | ||
| Weighted Harmonic Mean | public double weightedHarmonicMean_as_double() | |
| public Complex weightedHarmonicMean_as_Complex() | ||
| public bigDecimal weightedHarmonicMean_as_BigDecimal() | ||
|
Harmonic Mean Static methods | Harmonic Mean | public static double harmonicMean(double[] a) |
| public static float harmonicMean(float[] a) | ||
| public static Complex harmonicMean(Complex[] a) | ||
| public static BigDecimal harmonicMean(BigDecimal[] a) | ||
| public static BigDecimal harmonicMean(BigInteger[] a) | ||
| Weighted Harmonic Mean | public static double harmonicMean(double[] a, double[] w) | |
| public static float harmonicMean(float[] a, float[] w) | ||
| public static Complex harmonicMean(Complex[] a, Complex[] w) | ||
| public static BigDecimal harmonicMean(BigDecimal[] a, BigDecimal[] w) | ||
| public static BigDecimal harmonicMean(BigInteger[] a, BigInteger[] w) | ||
|
Generalised Mean (Power Mean) Instance methods |
Generalised Mean (Power Mean) | public double generalisedMean_as_double(double m) |
| public double generalisedMean_as_double(BigDecimal m) | ||
| public Complex generalisedMean_as_Complex(double m) | ||
| public Complex generalisedMean_as_Complex(Complex m) | ||
|
Weighted Generalised Mean (Weighted Power Mean) | public double weightedGeneralisedMean_as_double(double m) | |
| public double weightedGeneralisedMean_as_double(BigDecimal m) | ||
| public Complex weightedGeneralisedMean_as_Complex(double m) | ||
| public Complex weightedGeneralisedMean_as_Complex(Complex m) | ||
|
Generalised Mean (Power Mean) Static methods |
Generalised Mean (Power Mean) | public static double generalisedMean(double[] a, double m) |
| public static float generalisedMean(float[] a, float m) | ||
| public static Complex generalisedMean(Complex[] a, double m) | ||
| public static Complex generalisedMean(Complex[] a, Complexdouble m) | ||
| public static double generalisedMean(BigDecimal[] a, double m) | ||
| public static double generalisedMean(BigDecimal[] a, BigDecimal m) | ||
| public static double generalisedMean(BigInteger[] a, double m) | ||
| public static double generalisedMean(BigInteger[] a, BigInteger m) | ||
|
Weighted Generalised Mean (Weighted Power Mean) | public static double generalisedMean(double[] a, double[] w, double m) | |
| public static float generalisedMean(float[] a, float[] w,float m) | ||
| public static Complex generalisedMean(Complex[] a, Complex[] w, double m) | ||
| public static Complex generalisedMean(Complex[] a, Complex[] w, Complexdouble m) | ||
| public static double generalisedMean(BigDecimal[] a, BigDecimal[] w, double m) | ||
| public static double generalisedMean(BigDecimal[] a, BigDecimal[] w, BigDecimal m) | ||
| public static double generalisedMean(BigInteger[] a, BigInteger[] w, double m) | ||
| public static double generalisedMean(BigInteger[] a, BigInteger[] w, BigInteger m) | ||
|
Interquartile Mean Instance methods | Interquartile Mean | public double interQuartileMean_as_double() |
| public BigDecimal interQuartileMean_as_BigDecimal() | ||
|
Interquartile Mean Static methods | Interquartile Mean | public static double interQuartileMean(double[] a) |
| public static float interQuartileMean(float[] a) | ||
| public static BigDecimal interQuartileMean(BigDecimal[] a) | ||
| public static BigDecimal interQuartileMean(BigInteger[] a) | ||
|
Root Mean Square (rms) Instance method | Root Mean Square (rms) | public double rms() |
| Weighted Root Mean Square (wrms) | public double weightedRms() | |
|
Root Mean Square (rms) Static methods | Root Mean Square (rms) | public static double rms(double[] a) |
| public static float rms(float[] a) | ||
| public static BigDecimal rms(BigDecimal[] a) | ||
| public static BigDecimal rms(BigInteger[] a) | ||
| Weighted Root Mean Square (wrms) | public static double rms(double[] a, (double[] w) | |
| public static float rms(float[] a, float[] w) | ||
| public static BigDecimal rms(BigDecimal[] a, BigDecimal[] w) | ||
| public static BigDecimal rms(BigInteger[] a, BigInteger[] w) | ||
|
Median Instance methods | Median | public double median_as_double() |
| public BigDecimal median_as_BigDecimal() | ||
|
Median Static methods | Median | public static double median(double[] a) |
| public static float median(float[] a) | ||
| public static double median(int[] a) | ||
| public static double median(long[] a) | ||
| public static BigDecimal median(BigDecimal[] a) | ||
| public static BigDecimal median(BigInteger[] a) | ||
|
Set the denominator Instance methods | Set to n | public void setDenominatortoN() |
| Set to n-1 | public void setDenominatortoNminusOne() | |
|
Set the denominator Static methods | Set to n | public double setStaticDenominatortoN() |
| Set to n-1 | public double setStaticDenominatortoNminusOne() | |
|
Standard Deviation Instance methods | Standard Deviation | public double standardDeviation_as_double() |
| public Complex standardDeviation_as_Complex() | ||
| public double standardDeviation_as_Complex_ConjugateCalcn() | ||
| public double standardDeviation_of_ComplexModuli() | ||
| public double standardDeviation_of_ComplexRealParts() | ||
| public double standardDeviation_of_ComplexImaginaryParts() | ||
| Weighted Standard Deviation | public double weightedStandardDeviation_as_double() | |
| public Complex weightedStandardDeviation_as_Complex() | ||
| public double weightedStandardDeviation_as_Complex_ConjugateCalcn() | ||
| public oubled weightedStandardDeviation_of_ComplexModuli() | ||
| public oubled weightedStandardDeviation_of_ComplexRealParts() | ||
| public double weightedStandardDeviation_of_ComplexImaginaryParts() | ||
|
Standard Deviation Static methods | Standard Deviation | public static double standardDeviation(double[] a) |
| public static float standardDeviation(float[] a) | ||
| public static double standardDeviation(int[] a) | ||
| public static double standardDeviation(long[] a) | ||
| public static double standardDeviation(BigDecimal[] a | ||
| public static double standardDeviation(BigInteger[] a) | ||
| public static Complex standardDeviation(Complex[] a) | ||
| public static double standardDeviationConjugateCalcn(Complex[] a) | ||
| public static double standardDeviationModuli(Complex[] a) | ||
| public static double standardDeviationRealParts(Complex[] a) | ||
| public static double standardDeviationImaginaryParts(Complex[] a) | ||
| Weighted Standard Deviation | public static double standardDeviation(double[] a, double[] w) | |
| public static float standardDeviation(float[] a, float[] w) | ||
| public static double standardDeviation(BigDecimal[] a, BigDecimal[] w) | ||
| public static double standardDeviation(BigInteger[] a, BigInteger[] w) | ||
| public static Complex standardDeviation(Complex[] a, Complex[] w) | ||
| public static double standardDeviationConjugateCalcn(Complex[] a, Complex[] w) | ||
| public static double standardDeviationModuli(Complex[] a, Complex[] w) | ||
| public static double standardDeviationRealParts(Complex[] a, Complex[] w) | ||
| public static double standardDeviationImaginaryParts(Complex[] a, Complex[] w) | ||
|
Standard Error of the Mean Instance methods | Standard Error | public double standardError_as_double() |
| public Complex standardError_as_Complex() | ||
| public double standardError_as_Complex_ConjugateCalcn() | ||
| public double standardError_of_ComplexModuli() | ||
| public double standardError_of_ComplexRealParts() | ||
| public double standardError_of_ComplexImaginaryParts() | ||
| Weighted Standard Error | public double weightedStandardError_as_double() | |
| public Complex weightedStandardError_as_Complex() | ||
| public double weightedStandardError_as_Complex_ConjugateCalcn() | ||
| public double weightedStandardError_of_ComplexModuli() | ||
| public double weightedStandardError_of_ComplexRealParts() | ||
| public double weightedStandardError_of_ComplexImaginaryParts() | ||
|
Standard Error of the Mean Static methods | Standard Error | public static double standardError(double[] a) |
| public static float standardError(float[] a) | ||
| public static double standardError(int[] a) | ||
| public static double standardError(long[] a) | ||
| public static double standardError(BigDecimal[] a) | ||
| public static double standardError(BigInteger[] a) | ||
| public static Complex standardError(Complex[] a) | ||
| public static double standardErrorConjugateCalcn(Complex[] a) | ||
| public static double standardErrorModuli(Complex[] a) | ||
| public static double standardErrorRealParts(Complex[] a) | ||
| public static double standardErrorImaginaryParts(Complex[] a) | ||
| Weighted Standard Error | public static double standardError(double[] a, double[] w) | |
| public static float standardError(float[] a, float[] w) | ||
| public static double standardError(BigDecimal[] a, BigDecimal[] w) | ||
| public static double standardError(BigInteger[] a, BigInteger[] w) | ||
| public static Complex standardError(Complex[] a, Complex[] w) | ||
| public static double standardErrorConjugateCalcn(Complex[] a, Complex[] w) | ||
| public static double standardErrorModuli(Complex[] a, Complex[] w) | ||
| public static double standardErrorRealParts(Complex[] a, Complex[] w) | ||
| public static double standardErrorImaginaryParts(Complex[] a, Complex[] w) | ||
|
Volatility Instance methods | Volatility | public double volatilityLogChange() |
| public double volatilityPerCentChange() | ||
|
Volatility Static methods | Volatility | public static double volatilityLogChange(double[] a) |
| public static float volatilityLogChange(float[] a) | ||
| public static double volatilityLogChange(BigDecimal[] a) | ||
| public static double volatilityLogChange(Biginteger[] a) | ||
| public static double volatilityPerCentChange(double[] a) | ||
| public static float volatilityPerCentChange(float[] a) | ||
| public static double volatilityPerCentChange(BigDecimal[] a) | ||
| public static double volatilityPerCentChange(BigInteger[] a) | ||
|
Coefficient of variation Instance methods | Coefficient of variation | public double coefficientOfVariation() |
| Weighted coefficient of variation | public double weightedCoefficientOfVariation() | |
|
Coefficient of variation Static methods | Coefficient of variation | public static double coefficientOfVariation(double[] a) |
| public static float coefficientOfVariation(float[] a) | ||
| public static double coefficientOfVariation(BigDecimal[] a) | ||
| public static double coefficientOfVariation(BigInteger[] a) | ||
| Weighted coefficient of variation | public static double coefficientOfVariation(double[] a, double[] w) | |
| public static float coefficientOfVariation(float[] a, float[] w) | ||
| public static double coefficientOfVariation(BigDecimal[] a,BigDecimal[] w) | ||
| public static double coefficientOfVariation(BigInteger[] a, BigInteger[] w) | ||
|
Skewness Instance methods | Moment skewness | public double momentSkewness() |
| public double momentSkewness_as_double() | ||
| Median skewness | public double medianSkewness() | |
| public double medianSkewness_as_double() | ||
| Quartile skewness | public double quartileSkewness() | |
| public double quartileSkewness_as_double() | ||
| public BigDecimal quartileSkewness_as_BigDecimal() | ||
|
Skewness Static methods | Moment skewness | public static double momentSkewness(double[] a) |
| public static float momentSkewness(float[] a) | ||
| public static double momentSkewness(BigDecimal[] a) | ||
| public static double momentSkewness(BigInteger[] a) | ||
| public static double momentSkewness(int[] a) | ||
| public static double momentSkewness(long[] a) | ||
| Median skewness | public static double medianSkewness(double[] a) | |
| public static float medianSkewness(float[] a) | ||
| public static double medianSkewness(BigDecimal[] a) | ||
| public static double medianSkewness(BigInteger[] a) | ||
| public static double medianSkewness(int[] a) | ||
| public static double medianSkewness(long[] a) | ||
| Quartile skewness | public static double quartileSkewness(double[] a) | |
| public static float quartileSkewness(float[] a) | ||
| public static BigDecimal quartileSkewness(BigDecimal[] a) | ||
| public static BigDecimal quartileSkewness(BigInteger[] a) | ||
| public static double quartileSkewness(int[] a) | ||
| public static double quartileSkewness(long[] a) | ||
|
Kurtosis (Curtosis) Instance methods | Kurtosis | public double kurtosis() |
| public double kurtosis_as_double() | ||
| public BigDecimal kurtosis_as_BigDecimal() | ||
| Excess Kurtosis | public double excessKurtosis() | |
| public double excessKurtosis_as_double() | ||
| public BigDecimal excessKurtosis_as_BigDecimal() | ||
|
Kurtosis (Curtosis) Static methods | Kurtosis | public static double kurtosis(double[] a) |
| public static float kurtosis(float[] a) | ||
| public static BigDecimal kurtosis(BigDecimal[] a) | ||
| public static BigDecimal kurtosis(BigInteger[] a) | ||
| public static double kurtosis(int[] a) | ||
| public static double kurtosis(long[] a) | ||
| Excess Kurtosis | public static double excessKurtosis(double[] a) | |
| public static float excessKurtosis(float[] a) | ||
| public static BigDecimal excessKurtosis(BigDecimal[] a) | ||
| public static BigDecimal excessKurtosis(BigInteger[] a) | ||
| public static double excessKurtosis(int[] a) | ||
| public static double excessKurtosis(long[] a) | ||
|
Standardisation to a mean of 0 and standard deviation of 1 Instance methods | return standardised data | public double[] standardise() |
|
Standardisation to a mean of 0 and standard deviation of 1 Static methods | return standardised data | public static double[] standardise(double[] a) |
| public static float[] standardise(float[] a) | ||
| public static double[] standardise(BigDecimal[] a) | ||
| public static double[] standardise(BigInteger[] a) | ||
| public static double[] standardise(long[] a) | ||
| public static double[] standardise(int[] a) | ||
|
Scale to a new mean of and standard deviation Instance methods | return scaled data | public double[] scale(double mean, double sd) |
|
Scale to a new mean of and standard deviation Static methods | return scaled data | public static double[] scale(double[] a, double mean, double sd) |
| public static float[] scale(float[] a, float mean, float sd) | ||
| public static double[] scale(BigDecimal[] a, double mean, double sd) | ||
| public static double[] scale(BigInteger[] a, double mean, double sd) | ||
| public static double[] scale(long[] a, double mean, double sd) | ||
| public static double[] scale(int[] a, double mean, double sd) | ||
|
Variance Instance methods | Variance | public double variance_as_double() |
| public BigDecimal variance_as_BigDecimal() | ||
| public Complex variance_as_Complex() | ||
| public double variance_as_Complex_ConjugateCalcn() | ||
| public double variance_of_ComplexModuli() | ||
| public double variance_of_ComplexRealParts() | ||
| public double variance_of_ComplexImaginaryParts() | ||
| Weighted Variance | public double weightedVariance_as_double() | |
| public BigDecimal weightedVariance_as_BigDecimal() | ||
| public Complex weightedVariance_as_Complex() | ||
| public double weightedVariance_as_Complex_ConjugateCalcn() | ||
| public double weightedVariance_of_ComplexModuli() | ||
| public double weightedVariance_of_ComplexRealParts() | ||
| public double weightedVariance_of_ComplexImaginaryParts() | ||
|
Variance Static Methods | Variance | public static double variance(double[] a) |
| public static float variance(float[] a) | ||
| public static double variance(int[] a) | ||
| public static double variance(long[] a) | ||
| public static BigDecimal variance(BigDecimal[] a) | ||
| public static BigDecimal variance(BigInteger[] a) | ||
| public static Complex variance(Complex[] a) | ||
| public static double varianceConjugateCalcn(Complex[] a) | ||
| public static double varianceModuli(Complex[] a) | ||
| public static double varianceRealParts(Complex[] a) | ||
| public static double varianceImaginaryParts(Complex[] a) | ||
| Weighted Variance | public static double variance(double[] a, double[] w) | |
| public static float variance(float[] a, float[] w) | ||
| public static BigDecimal variance(BigDecimal[] a, BigDecimal[] w) | ||
| public static BigDecimal variance(BigInteger[] a, BigInteger[] w) | ||
| public static Complex variance(Complex[] a, Complex[] w) | ||
| public static double varianceConjugateCalcn(Complex[] a, Complex[] w) | ||
| public static double varianceModuli(Complex[] a, Complex[] w) | ||
| public static double varianceRealParts(Complex[] a, Complex[] w) | ||
| public static double varianceImaginaryParts(Complex[] a, Complex[] w) | ||
| Linear Correlation Coefficient | Correlation Coefficient | public static double corrCoeff(double[ ] x, double[ ] y) |
| public static float corrCoeff(float[ ] x, float[ ] y) | ||
| public static double corrCoeff(int[ ] x, int[ ] y) | ||
| public static double corrCoeff(int[ ][] freqMatrix) | ||
| public static double corrCoeff(int freqZeroZero, int freqZeroOne, int freqOneZero, int freqOneOne) | ||
| Weighted Correlation Coefficient | public static double corrCoeff(double[ ] x, double[ ] y, double[ ] w) | |
| Cumulative Distribution Function(cdf) | public static double corrCoeffCDFtwoTailed(double rCoeff, int nu) | |
| public static double corrCoeffCDFoneTailed(double rCoeff, int nu) | ||
| InverseCumulative Distribution Function(cdf) |
public static double corrCoeffInverseCDFtwoTailed(double prob, int nu) | |
|
public static double corrCoeffInverseCDFoneTailed(double prob, int nu) | ||
| Probability Density Function (pdf) | public static double corrCoeffPDF(double rCoeff, int nu) | |
| Covariance | Covariance | public static double covariance(double[ ] x, double[ ] y) |
| public static float covariance(float[ ] x, float[ ] y) | ||
| public static double covariance(int[ ] x, int[ ] y) | ||
| Weighted Covariance | public static double covariance(double[ ] x, double[ ] y, double[ ] w) | |
|
Order Statistic Medians | Uniform Order Statistic Medians | public static double[] uniformOrderStatisticMedians(int n) |
|
Gaussian [normal] Order Statistic Medians |
public static double[ ] gaussianOrderStatisticMedians(double mean, double sd, int n) public static double[ ] normalOrderStatisticMedians(double mean, double sd, int n) | |
|
public static double[ ] gaussianOrderStatisticMedians(int n) public static double[ ] normalOrderStatisticMedians(int n) | ||
|
Exponential Order Statistic Medians |
public static double[ ] exponentialOrderStatisticMedians(double mu, double sigma, int n) | |
|
F-Distribution Order Statistic Medians |
public static double[ ] fDistributionOrderStatisticMedians(int nu1, int nu2, int n) | |
|
Fréchet Order Statistic Medians |
public static double[ ] frechetOrderStatisticMedians(double mu, double sigma, double gamma, int n) public static double[ ] frechetOrderStatisticMedians(double sigma, double gamma, int n) public static double[ ] frechetOrderStatisticMedians(double gamma, int n) | |
|
Gumbel (minimum order statistic) Order Statistic Medians |
public static double[ ] gumbelMinOrderStatisticMedians(double mu, double sigma, int n) | |
|
Gumbel (maximum order statistic) Order Statistic Medians |
public static double[ ] gumbelMaxOrderStatisticMedians(double mu, double sigma, int n) | |
|
Logistic Order Statistic Medians |
public static double[ ] logisticOrderStatisticMedians(double mu, double beta, int n) | |
|
Lorentzian Order Statistic Medians |
public static double[ ] lorentzianOrderStatisticMedians(double mu, double gamma, int n) | |
|
Rayleigh Order Statistic Medians |
public static double[ ] rayleighOrderStatisticMedians(double beta, int n) | |
|
Weibull Order Statistic Medians |
public static double[ ] weibullOrderStatisticMedians(double mu, double sigma, double gamma, int n) public static double[ ] weibullOrderStatisticMedians(double sigma, double gamma, int n) public static double[ ] weibullOrderStatisticMedians(double gamma, int n) | |
| Gaussian (Normal) Distribution | Cumulative Distribution Function(cdf) |
public static double gaussianCDF(double mean, double sd, double limit) public static double normalCDF(double mean, double sd, double limit) |
|
public static double gaussianCDF(double mean, double sd, double lowerlimit, double upperlimit) public static double normalCDF(double mean, double sd, double lowerlimit, double upperlimit) | ||
| Inverse Cumulative Distribution Function |
public static double gaussianInverseCDF(double mean, double sd, double cdf) public static double normalInverseCDF(double mean, double sd, double cdf) public static double gaussianInverseCDF(double cdf) public static double normalInverseCDF(double cdf) | |
| Probability Density Function (pdf) |
public static double gaussianPDF(double mean, double sd, double x) public static double normalPDF(double mean, double sd, double x) | |
| Generate Gaussian [normal] random deviates |
public static double[ ] gaussianRand(double mean, double sd, int n) public static double[ ] normalRand(double mean, double sd, int n) | |
|
public static double[ ] gaussianRand(double mean, double sd, int n, long seed) public static double[ ] normalRand(double mean, double sd, int n, long seed) | ||
|
Gaussian [normal] Order Statistic Medians |
public static double[ ] gaussianOrderStatisticMedians(double mean, double sd, int n) public static double[ ] normalOrderStatisticMedians(double mean, double sd, int n) | |
|
public static double[ ] gaussianOrderStatisticMedians(int n) public static double[ ] normalOrderStatisticMedians(int n) | ||
|
Gaussian [normal] Probability Plot | See separate class ProbabilityPlot Gaussian Probability Plot methods | |
|
Fit data to a Gaussian [normal] distribution | public void fitOneOrSeveralDistributions() | |
| public static void fitOneOrSeveralDistributions(double[] array) | ||
| The ProbabilityPlot class Gaussian Probability Plot methods are also fitting methods | ||
| See also Regression class method gaussian() | ||
| See also Regression class method gaussianPlot() | ||
| Box-Cox transformation | See separate class BoxCox | |
|
Log-Normal Distributions Two parameter log-normal distribution (see below for the three parameter statistic) | Cumulative Distribution Function(cdf) |
public static double logNormalCDF(double mu, double sigma, double limit) public static double logNormalTwoParCDF(double mu, double sigma, double limit) |
|
public static double logNormalCDF(double mu, double sigma, double lowerlimit, double upperlimit) public static double logNormalTwoParCDF(double mu, double sigma, double lowerlimit, double upperlimit) | ||
| Probability Density Function (pdf) |
public static double logNormalPDF(double[] array=blue>double mu, double sigma, double x) public static double logNormalTwoParPDF(double mu, double sigma, double x) | |
| Generate two parameter log-normal distribution random deviates |
public static double[ ] logNormalRand(double mu, double sigma, int n) public static double[ ] logNormalTwoParRand(double mu, double sigma, int n) | |
|
public static double[ ] logNormalRand(double mu, double sigma, int n, long seed) public static double[ ] logNormalTwoParRand(double mu, double sigma, int n, long seed) | ||
| Mean |
public static double logNormalMean(double mu, double sigma) public static double logNormalTwoParMean(double mu, double sigma) | |
| Median |
public static double logNormalMedian(double mu) public static double logNormalTwoParMedian(double mu) | |
| Mode |
public static double logNormalMode(double , double sigmamu) public static double logNormalTwoParMode(double mu, double sigma) | |
| Standard deviation |
public static double logNormalStandardDeviation(double mu, double sigma) public static double logNormalTwoParStandardDeviation(double mu, double sigma) | |
|
Fit data to a Two Parameter Log-Normal distribution | public void fitOneOrSeveralDistributions() | |
| public static void fitOneOrSeveralDistributions(double[] array) | ||
|
Regression class method logNormal() Regression class method logNormalTwpPar() | ||
|
Regression class method logNormalPlot() Regression class method logNormalTwoParPlot() | ||
|
Log-Normal Distributions Three parameter log-normal distribution (see above for the two parameter statistic) | Cumulative Distribution Function(cdf) | public static double logNormalThreeParCDF(double alpha, double beta, double gamma, double limit) |
| public static double logNormalThreeParCDF(double alpha, double beta, double gamma, double lowerlimit, double upperlimit) | ||
| Probability Density Function (pdf) | public static double logNormalThreeParPDF(double alpha, double beta, double gamma, double x) | |
| Generate three parameter log normal distribution random deviates | public static double[ ] logNormalThreeParRand(double alpha, double beta, double gamma, int n) | |
| public static double[ ] logNormalThreeParRand(double alpha, double beta, double gamma, int n, long seed) | ||
| Mean | public static double logNormalThreeParMean(double alpha, double beta, double gamma) | |
| Median | public static double logNormalThreeParMedian(double alpha, double gamma) | |
| Mode | public static double logNormalThreeParMode(double alpha, double beta, double gamma) | |
| Standard deviation | public static double logNormalThreeParStandardDeviation(double alpha, double beta, double gamma) | |
|
Fit data to a Three Parameter Log-Normal distribution | public void fitOneOrSeveralDistributions() | |
| public static void fitOneOrSeveralDistributions(double[] array) | ||
| Regression class method logNormalThreePar() | ||
|
Regression class method logNormalThreeParPlot() | ||
|
Logistic Distribution (Sech squared Distribution) | Cumulative Distribution Function(cdf) |
public static double logisticCDF(double mu, double beta, double limit) |
|
public static double logisticCDF(double mu, double beta, double lowerlimit, double upperlimit) | ||
| Inverse Cumulative Distribution Function |
public static double logisticInverseCDF(double mu, double beta, double cdf) | |
| Probability Density Function (pdf) |
public static double logisticPDF(double mu, double beta, double x) | |
| Generate logistic distribution random deviates |
public static double[ ] logisticRand(double mu, double beta, int n) | |
|
public static double[ ] logisticRand(double mu, double beta, int n, long seed) | ||
| Mean | public static double logisticMean(double mu) | |
| Median | public static double logisticMedian(double mu) | |
| Mode | public static double logisticMode(double mu) | |
| Standard deviation | public static double logisticStandardDeviation(double beta) | |
|
Logistic Order Statistic Medians |
public static double[ ] logisticOrderStatisticMedians(double mu, double beta, int n) | |
|
Logistic Probability Plot | See separate class ProbabilityPlot Logistic Probability Plot methods | |
|
Fit data to a logistic distribution | public void fitOneOrSeveralDistributions() | |
| public static void fitOneOrSeveralDistributions(double[] array) | ||
| The ProbabilityPlot class Logistic Probability Plot methods are also fitting methods | ||
| Regression class method logistic() | ||
| Regression class method logisticPlot() | ||
| Lorentzian Distribution (Cauchy Distribution) | Cumulative Distribution Function(cdf) | public static double lorentzianCDF(double mean, double sd, double limit) |
| public static double lorentzianCDF(double mean, double gamma, double lowerlimit, double upperlimit) | ||
| Inverse Cumulative Distribution Function |
public static double lorentzianInverseCDF(double mu, double gamma, double cdf) | |
| Probability Density Function (pdf) | public static double lorentzianPDF(double mean, double gamma, double x) | |
| Generate Lorentzian random deviates | public static double[ ] lorentzianRand(double mu, double gamma, int n) | |
| public static double[ ] lorentzianRand(double mu, double gamma, int n, long seed) | ||
|
Lorentzian Order Statistic Medians |
public static double[ ] lorentzianOrderStatisticMedians(double mu, double gamma, int n) | |
| Lorentzian Probability Plot | See separate class ProbabilityPlot Lorentzian Probability Plot methods | |
|
Fit data to a Lorentzian distribution | The ProbabilityPlot class Lorentzian Probability Plot methods are also fitting methods | |
| public static void fitOneOrSeveralDistributions() | ||
| public void fitOneOrSeveralDistributions(double[] array) | ||
| Regression class method lorentzianPlot() | ||
| Regression class method lorentzian() | ||
| Poisson Distribution | Cumulative Distribution Function(cdf) | public static double poissonCDF(int k, double mean) |
| Probability Density Function (pdf) | public static double poissonPDF(int k, double mean) | |
| Generate Poisson random deviates | public static double[ ] poissonRand(double mean, int n) | |
| public static double[ ] poissonRand(double mean, int n, long seed) | ||
|
Fit data to a Poisson distribution | Regression class method poissonPlot() | |
| Regression class method poisson() | ||
|
Type 1 Extreme Value Distribution (minimum order statistic) Gumbel Distribution (minimum order statistic) | Cumulative Distribution Function(cdf) | public static double gumbelMinCDF(double mu, double sigma, double limit) |
| public static double gumbelMinCDF(double mean, double sigma, double lowerlimit, double upperlimit) | ||
| Inverse Cumulative Distribution Function |
public static double gumbelMinInverseCDF(double mu, double sigma, double cdf) | |
| Probability Density Function (pdf) | public static double gumbelMinPDF(double mu, double sigma, double x) | |
| Generate Minimal Gumbel random deviates | public static double[ ] gumbelMinRand(double mu, double sigma, int n) | |
| public static double[ ] gumbelMinRand(double mu, double sigma, int n, long seed) | ||
| Mean | public static double gumbelMinMean(double mu, double sigma) | |
| Median | public static double gumbelMinMedian(double mu, double sigma) | |
| Mode | public static double gumbelMinMode(double mu, double sigma) | |
| Standard deviation | public static double gumbelMinStandardDeviation(double sigma) | |
|
Gumbel (minimum order statistic) Order Statistic Medians |
public static double[ ] gumbelMinOrderStatisticMedians(double mu, double sigma, int n) | |
|
Gumbel [minimum order statistic] Probability Plot | See separate class ProbabilityPlot Gumbel [[minimum order statistic] Probability Plot methods | |
|
Fit data to a Gumbel distribution (minimum order statistic) | public void fitOneOrSeveralDistributions() | |
| public static void fitOneOrSeveralDistributions(double[] array) | ||
| The ProbabilityPlot class Gumbel (minimum order statistic) Probability Plot methods are also fitting methods | ||
| Regression class method gumbelMinPlot() | ||
| Regression class method gumbelMin() | ||
| Regression class method gumbelMinOneParPlot() | ||
| Regression class method gumbelMinOnePar() | ||
| Regression class method gumbelMinStandardPlot() | ||
| Regression class method gumbelMinStandard() | ||
|
Type 1 Extreme Value Distribution (maximum order statistic) Gumbel Distribution (maximum order statistic) | Cumulative Distribution Function(cdf) | public static double gumbelMaxCDF(double mu, double sigma, double limit) |
| public static double gumbelMaxCDF(double mean, double sigma, double lowerlimit, double upperlimit) | ||
| Inverse Cumulative Distribution Function |
public static double gumbelMaxInverseCDF(double mu, double sigma, double cdf) | |
| Probability Density Function (pdf) | public static double gumbelMaxPDF(double mu, double sigma, double x) | |
| Generate Maximal Gumbel random deviates | public static double[ ] gumbelMaxRand(double mu, double sigma, int n) | |
| public static double[ ] gumbelMaxRand(double mu, double sigma, int n, long seed) | ||
| Mean | public static double gumbelMaxMean(double mu, double sigma) | |
| Median | public static double gumbelMaxMedian(double mu, double sigma) | |
| Mode | public static double gumbelMaxMode(double mu, double sigma) | |
| Standard deviation | public static double gumbelMaxStandardDeviation(double sigma) | |
|
Gumbel (maximum order statistic) Order Statistic Medians |
public static double[ ] gumbelMaxOrderStatisticMedians(double mu, double sigma, int n) | |
|
Gumbel [maximum order statistic] Probability Plot | See separate class ProbabilityPlot Gumbel [[maximum order statistic] Probability Plot methods | |
|
Fit data to a Gumbel Distribution (maximum order statistic) | public void fitOneOrSeveralDistributions() | |
| public static void fitOneOrSeveralDistributions(double[] array) | ||
| The ProbabilityPlot class Gumbel (maximum order statistic) Probability Plot methods are also fitting methods | ||
| Regression class method gumbelMaxPlot() | ||
| Regression class method gumbelMax() | ||
| Regression class method gumbelMaxOneParPlot() | ||
| Regression class method gumbelMaxOnePar() | ||
| Regression class method gumbelMaxStandardPlot() | ||
| Regression class method gumbelMaxStandard() | ||
|
Type 2 Extreme Value Distribution Fréchet Distribution | Cumulative Distribution Function(cdf) | public static double frechetCDF(double mu, double sigma, double gamma, double limit) |
| public static double frechetCDF(double mean, double sigma, double gamma, double lowerlimit, double upperlimit) | ||
| Inverse Cumulative Distribution Function |
public static double frechetInverseCDF(double mu, double sigma, double gamma, double cdf) public static double frechetInverseCDF(double sigma, double gamma, double cdf) public static double frechetInverseCDF(double gamma, double cdf) | |
| Probability Density Function (pdf) | public static double frechetPDF(double mu, double sigma, double gamma, double x) | |
| Generate Fréchet random deviates | public static double[ ] frechetRand(double mu, double sigma, double gamma, int n) | |
| public static double[ ] frechetRand(double mu, double sigma, double gamma, int n, long seed) | ||
| Mean | public static double frechetMean(double mu, double sigma, double gamma) | |
| Mode | public static double frechetMode(double mu, double sigma, double gamma) | |
| Standard deviation | public static double frechetStandardDeviation(double sigma, double gamma) | |
|
Fréchet Order Statistic Medians |
public static double[ ] frechetOrderStatisticMedians(double mu, double sigma, double gamma, int n) public static double[ ] frechetOrderStatisticMedians(double sigma, double gamma, int n) public static double[ ] frechetOrderStatisticMedians(double gamma, int n) | |
|
Fréchet Probability Plot | See separate class ProbabilityPlot Fréchet Probability Plot methods | |
|
Fit data to a Fréchet distribution | public void fitOneOrSeveralDistributions() | |
| public static void fitOneOrSeveralDistributions(double[] array) | ||
| The ProbabilityPlot class Fréchet Probability Plot methods are also fitting methods | ||
| Regression class method frechetPlot() | ||
| Regression class method frechet() | ||
| Regression class method frechetTwoParPlot() | ||
| Regression class method frechetTwoPar() | ||
| Regression class method frechetStandardPlot() | ||
| Regression class method frechetStandard() | ||
|
Type 3 Extreme Value Distribution Weibull Distribution | Cumulative Distribution Function(cdf) | public static double weibullCDF(double mu, double sigma, double gamma, double limit) |
| public static double weibullCDF(double mean, double sigma, double gamma, double lowerlimit, double upperlimit) | ||
| Inverse Cumulative Distribution Function |
public static double weibullInverseCDF(double mu, double sigma, double gamma, double cdf) public static double weibullInverseCDF(double sigma, double gamma, double cdf) public static double weibullInverseCDF(double gamma, double cdf) | |
| Probability Density Function (pdf) | public static double weibullPDF(double mu, double sigma, double gamma, double x) | |
| Generate Weibull random deviates | public static double[ ] weibullRand(double mu, double sigma, double gamma, int n) | |
| public static double[ ] weibullRand(double mu, double sigma, double gamma, int n, long seed) | ||
| Mean | public static double weibullMean(double mu, double sigma, double gamma) | |
| Median | public static double weibullMedian(double mu, double sigma, double gamma) | |
| Mode | public static double weibullMode(double mu, double sigma, double gamma) | |
| Standard deviation | public static double weibullStandardDeviation(double sigma, double gamma) | |
|
Weibull Order Statistic Medians |
public static double[ ] weibullOrderStatisticMedians(double mu, double sigma, double gamma, int n) public static double[ ] weibullOrderStatisticMedians(double sigma, double gamma, int n) public static double[ ] weibullOrderStatisticMedians(double gamma, int n) | |
|
Weibull Probability Plot | See separate class ProbabilityPlot Weibull Probability Plot methods | |
|
Fit data to a Weibull distribution | public void fitOneOrSeveralDistributions() | |
| public static void fitOneOrSeveralDistributions(double[] array) | ||
| The ProbabilityPlot class Weibull Probability Plot methods are also fitting methods | ||
| Regression class method weibullPlot() | ||
| Regression class method weibull() | ||
| Regression class method weibullTwoParPlot() | ||
| Regression class method weibullTwoPar() | ||
| Regression class method weibullStandardPlot() | ||
| Regression class method weibullStandard() | ||
|
Type 3 Extreme Value Distribution Exponential Distribution | Cumulative Distribution Function(cdf) | public static double exponentialCDF(double mu, double sigma, double limit) |
| public static double exponentialCDF(double mean, double sigma, double lowerlimit, double upperlimit) | ||
| Inverse Cumulative Distribution Function |
public static double exponentialInverseCDF(double mu, double sigma, double cdf) | |
| Probability Density Function (pdf) | public static double exponentialPDF(double mu, double sigma, double x) | |
| Generate exponential random deviates | public static double[ ] exponentialRand(double mu, double sigma, int n) | |
| public static double[ ] exponentialRand(double mu, double sigma, int n, long seed) | ||
| Mean | public static double exponentialMean(double mu, double sigma) | |
| Median | public static double exponentialMedian(double mu, double sigma) | |
| Mode | public static double exponentialMode(double mu) | |
| Standard deviation | public static double exponentialStandardDeviation(double sigma) | |
|
Exponential Order Statistic Medians |
public static double[ ] exponentialOrderStatisticMedians(double mu, double sigma, int n) | |
|
Exponential Probability Plot | See separate class ProbabilityPlot Exponential Probability Plot methods | |
|
Fit data to a exponential distribution | public void fitOneOrSeveralDistributions() | |
| public static void fitOneOrSeveralDistributions(double[] array) | ||
| The ProbabilityPlot class Exponential Probability Plot methods are also fitting methods | ||
| Regression class method exponentialPlot() | ||
| Regression class method exponential() | ||
| Regression class method exponentialOneParPlot() | ||
| Regression class method exponentialOnePar() | ||
| Regression class method exponentialStandardPlot() | ||
| Regression class method exponentialStandard() | ||
|
Type 3 Extreme Value Distribution Rayleigh Distribution | Cumulative Distribution Function(cdf) | public static double rayleighCDF(double beta, double limit) |
| public static double rayleighCDF(double beta, double lowerlimit, double upperlimit) | ||
| Inverse Cumulative Distribution Function |
public static double rayleighInverseCDF(double beta, double cdf) | |
| Probability Density Function (pdf) | public static double rayleighPDF(double beta, double x) | |
| Generate Rayleigh random deviates | public static double[ ] rayleighRand(double beta, int n) | |
| public static double[ ] rayleighRand(double beta, int n, long seed) | ||
| Mean | public static double rayleighMean(double beta) | |
| Median | public static double rayleighMedian(double beta) | |
| Mode | public static double rayleighMode(double beta) | |
| Standard deviation | public static double rayleighStandardDeviation(double beta) | |
|
Rayleigh Order Statistic Medians |
public static double[ ] rayleighOrderStatisticMedians(double beta, int n) | |
|
Rayleigh Probability Plot | See separate class ProbabilityPlot Rayleigh Probability Plot methods | |
|
Fit data to a Rayleigh distribution | public void fitOneOrSeveralDistributions() | |
| public static void fitOneOrSeveralDistributions(double[] array) | ||
| The ProbabilityPlot class Rayleigh Probability Plot methods are also fitting methods | ||
| Regression class method rayleighPlot() | ||
| Regression class method rayleigh() | ||
| Pareto Distribution | Cumulative Distribution Function(cdf) | public static double paretoCDF(double alpha, double beta, double limit) |
| public static double paretoCDF(double alpha, double beta, double lowerlimit, double upperlimit) | ||
| Inverse Cumulative Distribution Function |
public static double paretoInverseCDF(double alpha, double beta, double cdf) | |
| Probability Density Function (pdf) | public static double paretoPDF(double alpha, double beta, double x) | |
| Generate Pareto random deviates | public static double[ ] paretoRand(double alpha, double beta, int n) | |
| public static double[ ] paretoRand(double alpha, double beta, int n, long seed) | ||
| Mean | public static double paretoMean(double alpha, double beta) | |
| Mode | public static double paretoMode(double beta) | |
| Standard deviation | public static double paretoStandardDeviation(double alpha, double beta) | |
|
Pareto Order Statistic Medians |
public static double[ ] paretoOrderStatisticMedians(double alpha, double beta, int n) | |
|
Pareto Probability Plot | See separate class ProbabilityPlot Pareto Probability Plot methods | |
|
Fit data to a Pareto distribution | public void fitOneOrSeveralDistributions() | |
| public static void fitOneOrSeveralDistributions(double[] array) | ||
| The ProbabilityPlot class Pareto Probability Plot methods are also fitting methods | ||
| Regression class method paretoThreeParPlot() | ||
| Regression class method paretoThreePar() | ||
|
Regression class method paretoTwoParPlot() Regression class method paretoPlot() | ||
|
Regression class method paretoTwoPar() Regression class method pareto() | ||
| Regression class method paretoOneParPlot() | ||
| Regression class method paretoOnePar() | ||
| Binomial Distribution | Cumulative Distribution Function (cdf) | public static double binomalCDF(double p, int n, int k) |
| probability density function (pdf) | public static double binomialPDF(double p, int n, int k) | |
| Generate Binomial random deviates | public static double binomialRand(int p , int nTrials, int nArrays) | |
| public static double binomialRand(int p , int nTrials, int nArrays, long seed) | ||
| Binomial Coefficients | public static double binomialCoeff(int n , int k) | |
| Student's t Distribution | Cumulative Distribution Function (cdf) | public static double studentstCDF(double tValue, int nu) |
| public static double studentstCDF(double lowerLimit, double upperLimit, int nu) | ||
| P-value | public static double pValue(double tValue, int nu) | |
| Probability density function (pdf) | public static double studentstPDF(double tValue, int nu) | |
| Student's t value for a given cdf | public static double studentstValue(double cdf, int nu) | |
| Generate Student's t random deviates | public static double[] studentstRand(int nu, int n) | |
| public static double[] studentstRand(int nu, int n, long seed) | ||
| Mean | public static double studentstMean(int nu) | |
| Median | public static double studentstMedian() | |
| Mode | public static double studentstMode() | |
| Standard deviation | public static double studentstStandardDeviation(int nu) | |
| A(t|n) distribution | public static double probAtn(double tValue, int nu) | |
| Beta Distribution and Beta Functions | Cumulative Distribution Function(cdf) | public static double betaCDF(double min, double max, double alpha, double beta, double limit) |
| public static double betaCDF(double alpha, double beta, double limit) | ||
| Probability Density Function (pdf) | public static double betaPDF(double min, double max, double alpha, double beta, double x) | |
| public static double betaPDF(double alpha, double beta, double x) | ||
| Generate Beta random deviates | public static double[ ] betaRand(double min, double max, double alpha, double beta, int n) | |
| public static double[ ] betaRand(double alpha, double beta, int n) | ||
| public static double[ ] betaRand(double min, double max, double alpha, double beta, int n, long seed) | ||
| public static double[ ] betaRand(double alpha, double beta, int n, long seed) | ||
| Mean | public static double betaMean(double min, double max, double alpha, double beta) | |
| public static double betaMean(double alpha, double beta) | ||
| Mode | public static double betaMode(double mu, , double beta, double beta,) | |
| public static double betaMode(double alpha, double beta) | ||
| Standard deviation | public static double betaStandardDeviation(double beta, double beta,) | |
| public static double betaStandardDeviation(double alpha, double beta) | ||
|
Fit data to a Beta distribution | public void fitOneOrSeveralDistributions() | |
| public static void fitOneOrSeveralDistributions(double[] array) | ||
| Regression class method beta() | ||
| Regression class method betaPlot() | ||
| Regression class method betaMinMax() | ||
| Regression class method betaMinMaxPlot() | ||
| Beta Function | public static double betaFunction(double z , double w) | |
| Regularised Incomplete Beta Function |
public static double regularisedBetaFunction(double z , double w, double x) public static double regularizedBetaFunction(double z , double w, double x) public static void resetCFmaxIter(int maxit) public static int getCFmaxIter() public static void resetCFtolerance(double tolerance) public static double getCFtolerance() | |
| Gamma Distribution and Gamma Functions | Cumulative Distribution Function(cdf) | public static double gammaCDF(double mu, double beta, double gamma, double limit) |
| public static double gammaCDF(double gamma, double limit) | ||
| Probability Density Function (pdf) | public static double gammaPDF(double mu, double beta, double gamma, double x) | |
| public static double gammaPDF(double gamma, double x) | ||
| Generate Gamma random deviates | public static double[ ] gammaRand(double mu, double beta, double gamma, int n) | |
| public static double[ ] gammaRand(double mu, double beta, double gamma, int n, long seed) | ||
| Mean | public static double gammaMean(double mu, double beta, double gamma) | |
| Mode | public static double gammaMode(double mu, , double beta, double gamma,) | |
| Standard deviation | public static double gammaStandardDeviation(double beta, double gamma) | |
|
Fit data to a Gamma distribution | public void fitOneOrSeveralDistributions() | |
| public static void fitOneOrSeveralDistributions(double[] array) | ||
| Regression class method gamma() | ||
| Regression class method gammaPlot() | ||
| Regression class method gammaStandard() | ||
| Regression class method gammaStandardPlot() | ||
| Gamma Function | public static double gammaFunction(double x) | |
| Lanczos approximation settings | public static double getLanczosGamma() | |
| public static int getLanczosN() | ||
| public static double[] getLanczosCoeff() | ||
| log(Gamma Function) | public static double logGammaFunction(double x) | |
| Inverse Gamma Function | public static double[] inverseGammaFunction(double gamma) | |
| Regularised Incomplete Gamma Function |
public static double regularisedGammaFunction(double a, double x) public static double regularizedGammaFunction(double a, double x) | |
| Complementary Regularised Incomplete Gamma Function |
public static double complementaryRegularisedGammaFunction(double a, double x) public static double complementaryRegularizedGammaFunction(double a, double x) | |
| Incomplete Gamma Function approximation settings | public static void setIncGammaMaxIter(int nmax) | |
| public static int getIncGammaMaxIter() | ||
| public static void setIncGammaTol(double tol) | ||
| public static double getIncGammaTol() | ||
| Gamma Function Minimum | public static double[] gammaFunctionMinimum() | |
| Erlang Distribution and Erlang connections busy, B and C Equations | Cumulative Distribution Function(cdf) |
public static double erlangCDF(double lambda, int kay, double limit) public static double erlangCDF(double lambda, long kay, double limit) public static double erlangCDF(double lambda, double kay, double limit) |
| Probability Density Function (pdf) |
public static double erlangPDF(double lambda, int kay, double x) public static double erlangPDF(double lambda, long kay, double x) public static double erlangPDF(double lambda, double kay, double x) | |
| Generate Erlang random deviates |
public static double[ ] erlangRand(double lambda, int kay, int n) public static double[ ] erlangRand(double lambda, long kay, int n) public static double[ ] erlangRand(double lambda, double kay, int n) | |
|
public static double[ ] erlangRand(double lambda, int kay, int n, long seed) public static double[ ] erlangRand(double lambda, long kay, int n, long seed) public static double[ ] erlangRand(double lambda, double kay, int n, long seed) | ||
| Mean |
public static double erlangMean(double lambda, int kay) public static double erlangMean(double lambda, long kay) public static double erlangMean(double lambda, double kay) | |
| Mode |
public static double erlangMode(double lambda, int kay) public static double erlangMode(double lambda, long kay) public static double erlangMode(double lambda, idouble kay) | |
| Standard deviation |
public static double erlangStandardDeviation(double lambda, int kay) public static double erlangStandardDeviation(double lambda, long kay) public static double erlangStandardDeviation(double lambda, break kay) | |
|
Fit data to an Erlang distribution | public void fitOneOrSeveralDistributions() | |
| public static void fitOneOrSeveralDistributions(double[] array) | ||
| Regression class method erlang() | ||
| Regression class method erlangPlot() | ||
|
Erlang connections busy probability | public static double erlangMprobability(double totalTraffic, double totalResources, double em) public static double erlangMprobability(double totalTraffic, long totalResourceslong em) public static double erlangMprobability(double totalTraffic, int totalResourcesint em) | |
|
Erlang B Equation |
public static double erlangBprobability(double totalTraffic, double totalResources) public static double erlangBprobability(double totalTraffic, long totalResources) public static double erlangBprobability(double totalTraffic, int totalResources) | |
|
public static double erlangBload(double blockingProbability, double totalResources) public static double erlangBload(double blockingProbability, long totalResources) public static double erlangBload(double blockingProbability, int totalResources) | ||
|
public static double[] erlangBresources(double blockingProbability, double totalTraffic) | ||
|
Erlang C Equation |
public static double erlangCprobability(double totalTraffic, double totalResources) public static double erlangCprobability(double totalTraffic, long totalResources) public static double erlangCprobability(double totalTraffic, int totalResources) | |
|
public static double erlangCload(double nonZeroDelayProbability, double totalResources) public static double erlangCload(double nonZeroDelayProbability, long totalResources) public static double erlangCload(double nonZeroDelayProbability, int totalResources) | ||
|
public static double[] erlangCresources(double nonZeroDelayProbability, double totalTraffic) | ||
| Engset Equation | Engset probability |
public static double engsetProbability(double offeredTraffic, double totalResources, double numberOfSources) public static double engsetProbability(double offeredTraffic, long totalResources, long numberOfSources) public static double engsetProbability(double offeredTraffic, int totalResources, int numberOfSources) |
| Engset load |
public static double engsetLoad(double blockingProbability, double totalResources, double numberOfSources) public static double engsetLoad(double blockingProbability, long totalResources, long numberOfSources) public static double engsetLoad(double blockingProbability, int totalResources, int numberOfSources) | |
| Engset resources |
public static double[] engsetResources(double blockingProbability, double offeredTraffic, double numberOfSources) public static double[] engsetResources(double blockingProbability, double offeredTraffic, long numberOfSources) public static double[] engsetResources(double blockingProbability, double offeredTraffic, int numberOfSources) | |
| Engset number of sources |
public static double[] engsetSources(double blockingProbability, double offeredTraffic, double reources) public static double[] engsetSources(double blockingProbability, double offeredTraffic, long resources) public static double[] engsetSources(double blockingProbability, double offeredTraffic, int resources) | |
| Chi-Square Distribution and Chi-Square Statistic | Cumulative Distribution Function (cdf) | public static double chiSquareCDF(double chiSquare, int nu) | Inverse Cumulative Distribution Function | public static double chiSquareInverseCDF(int nu, double cdfProb) |
| Probability Density Function (pdf) | public static double chiSquarePDF(double chiSquare, int nu) | |
| Generate exponential random deviates | public static double[ ] chiSquareRand(int nu, int n) | |
| public static double[ ] chiSquareRand(int nu, int n, long seed) | ||
| Mean | public static double chiSquareMean(int nu) | |
| Mode | public static double chiSquareMode(int nu) | |
| Standard Deviation | public static double chiSquareStandardDeviation(int nu) | |
| Statistic | public static double chiSquare(double[ ] observed, double[ ] expected, double[ ] variance) | |
| public static double chiSquareFreq(int[ ] observedFreq, int[ ] expectedfreq) | ||
| public static double chiSquareFreq(double[ ] observedFreq, double[ ] expectedFreq) | ||
| Wilson-Hilferty Transform | public static double wilsonHilferty(double chiSquare, int nu) | |
| public static double wilsonHilferty(double reducedChiSquare, double variance) | ||
| F-Distribution | Cumulative Distribution Function (cdf) [Complement]; |
public static double fCompCDF(double fValue, int nu1, int nu2) |
|
public static double fCompCDF(double var1, int nu1, double var2, int nu2) | ||
| public static double fTestValueGivenFprob(double fProb, int nu1, int nu2) | ||
| Inverse Cumulative Distribution Function |
public static double fdistributionInverseCDF(int nu1, int nu2, double cdf) | |
| Probability Density Function (pdf) ; |
public static double fPDF(double fValue, int nu1, int nu2) | |
|
public static double fPDF(double var1, int nu1, double var2, int nu2) | ||
| Generate F-distribution random deviates | public static double[ ] fRand(int nu1, int nu2, int n) | |
| public static double[ ] fRand(int nu1, int nu2, int n, long seed) | ||
|
F-Distribution Order Statistic Medians |
public static double[ ] fDistributionOrderStatisticMedians(int nu1, int nu2, int n) | |
|
F-Distribution Probability Plot | See separate class ProbabilityPlot F-Distribution Probability Plot methods | |
| Fit data array to one or several distributions | Instance method | public void fitOneOrSeveralDistributions() |
| Static method | public static void fitOneOrSeveralDistributions(double[] array) | |
| Error Functions | Error Function | public static double erf(double x) |
| Complementary Error Function | public static double erfc(double x) | |
| Factorials | Factorial | public static int factorial(int n) |
| public static long factorial(long n) | ||
| public static BigInteger factorial(BigInteger n) | ||
| public static double factorial(double n) | ||
| public static BigDecimal factorial(BigDecimal n) | ||
| log(factorial) | public static double logFactorial(int n) | |
| public static double logFactorial(long n) | ||
| public static double logFactorial(double n) | ||
|
Shannon Entropy Instance methods | Shannon entropy as bits | public double shannonEntropy() |
| public double shannonEntropyBit() | ||
| Shannon entropy as nats | public double shannonEntropyNat() | |
| Shannon entropy as dits | public double shannonEntropyDit() | |
|
Shannon Entropy Static methods | Shannon entropy as bits | public static double shannonEntropy(double[] p) |
| public static double shannonEntropyBit(double[] p) | ||
| Shannon entropy as nats | public static double shannonEntropyNat(double[] p) | |
| Shannon entropy as dits | public static double shannonEntropyDit(double[] p) | |
| Binary Shannon entropy as bits | public static double binaryShannonEntropy(double p) | |
| public static double binaryShannonEntropyBit(double p) | ||
| Binary Shannon entropy as nats | public static double binaryShannonEntropyNat(double p) | |
| Binary Shannon entropy as dits | public static double binaryShannonEntropyDit(double p) | |
|
Rényi Entropy Instance methods | Rényi entropy as bits | public double renyiEntropy(double alpha) |
| public double renyiEntropyBit(double alpha) | ||
| Rényi entropy as nats | public double renyiEntropyNat(double alpha) | |
| Rényi entropy as dits | public double renyiEntropyDit(double alpha) | |
|
Rényi Entropy Static methods | Rényi entropy as bits | public static double renyiEntropy(double[] p, double alpha) |
| public static double renyiEntropyBit(double[] p, double alpha) | ||
| Rényi entropy as nats | public static double renyiEntropyNat(double[] p, double alpha) | |
| Rényi entropy as dits | public static double renyiEntropyDit(double[] p, double alpha) | |
|
Tsallis Entropy Instance method | Tsallis Entropy (as nats) | public double tsallisEntropyNat(double q) |
|
Tsallis Entropy Static method | Tsallis Entropy (as nats) | public static double tsallisEntropyNat(double[] p, double q) |
|
A Generalised Entropy Instance method | A Generalised Entropy (as nats) | public double generalisedEntropyOneNat(double q, double r) |
|
A Generalised Entropy Static method | A Generalised Entropy (as nats) | public static double generalisedEntropyOneNat(double[] p, double q, double r) |
| Histograms | public static double histogramBins(double[ ] data, double binWidth, double lowerLimit, double upperLimit) | public static double histogramBins(double[ ] data, double binWidth, double lowerLimit) |
| public static double histogramBins(double[ ] data, doublebinWidth) | ||
| public static double histogramBinsPlot(double[ ] data, double binWidth, double lowerLimit, double upperLimit) | ||
| public static double histogramBinsPlot(double[ ] data, double binWidth, double lowerLimit, double upperLimit, String xLegend) | ||
| public static double histogramBinsPlot(double[ ] data, double binWidth, double lowerLimit) | ||
| public static double histogramBinsPlot(double[ ] data, double binWidth, double lowerLimit, String xLegend) | ||
| public static double histogramBinsPlot(double[ ] data, double binWidth) | ||
| public static double histogramBinsPlot(double[ ] data, double binWidth, String xLegend) | ||
| Outlier detection | Outlier detection methods are now included in a separate class, Outliers | |
















































or 

or 
or 
or 
or 






















is the sample mean and s is the sample standard deviation. The array should be entered via the Contructor
as any of the types allowed by the constructor.


is the sample mean and s is the sample standard deviation.
The array aa may be an array of double, float, BigDecimal, BigInteger, int or long. The skewness is returned as a double or float.


is the sample mean and s is the sample standard deviation. The array should be entered via the Contructor
as any of the types allowed by the constructor.
is the sample mean and s is the sample standard deviation, i.e. returns the kurtosis minus the kurtosis of a Gaussian distribution (3.0). The array should be entered via the Contructor
as any of the types allowed by the constructor. kurtosisExcess may be used in place of excessKurtosis in the method names.
is the sample mean and s is the sample standard deviation.
The array aa may be an array of double, float, BigDecimal, BigInteger, int or long. The kurosis is returned as a double, float or BigDecimal.
is the sample mean and s is the sample standard deviation, i.e. returns the kurtosis minus the kurtosis of a Gaussian distribution (3.0).
The array aa may be an array of double, float, BigDecimal, BigInteger, int or long. The excess kurosis is returned as a double, float or BigDecimal. kurtosisExcess may be used in place of excessKurtosis in the method names.
is the mean and s is the standard deviation of the data before standardisation.
The array should be entered via the Contructor
as any of the types allowed by the constructor.
is the mean and s is the standard deviation of aa before standardisation.
The variables in the array aa may be double, float, long, int, BigDecimal or BigInteger x. The standardised array is returned as an array of doubles or, in the case of aa entered as float, an array of float.
and s1 are the mean and standard deviation of the internal array before scaling and
and s2 are the required mean [mean] and standard deviation [sd].
The array should be entered via the Contructor
as any of the types allowed by the constructor.
and s1 are the mean and standard deviation of aa before scaling and
and s2 are the required mean [mean] and standard deviation [sd].
The variables in the array aa may be double, float, long, int, BigDecimal or BigInteger x. The standardised array is returned as an array of doubles or, in the case of aa entered as float, an array of float.
















































































Mode
public static double weibullMode(double mu, double sigma, double gamma)
Usage:
mode = Stat.weibullMode(mu, sigma, gamma);
Returns the mode, i.e. the x value at which the Weibull distribution is at a maximum, where

and μ [argument double mu] is the location parameter, σ [argument double sigma] is the scale parameter and γ [argument double gamma] is the shape parameter.
Standard Deviation
public static double weibullStandardDeviation(double sigma, double gamma)
Usage:
sd = Stat.weibullStandardDeviation(sigma, gamma);
Returns the standard deviation of a Weibull distribution, where

and σ [argument double sigma] is the scale parameter and γ [argument double gamma] is the shape parameter.
Weibull Probabilty Plot
Probabilty Plots are now handled by a separate dedicated class, ProbabilityPlot
Fit data to a Weibull Distribution
If the data is in the form of an x and a y data set, e..g. xdata and ydata, use the constructor:
Regression reg = new Regression(xdata, ydata)
or
Regression reg = new Regression(xdata, ydata, weight)
Then:
Fitting data to the Three Parameter Weibull Distribution function

use either the method:
reg.weibullPlot()
or
reg.weibull()
Fitting data to the Two Parameter Weibull Distribution function

use either the method:
reg.weibullTwoParPlot()
or
reg.weibullTwoPar()
Fitting data to the Standard Weibull Distribution function

use either the method:
reg.weibullStandardPlot()
or
reg.weibullStandard()
See Regression class for details of these constructors and methods and for the methods by which the results may be accessed.













































































































