Documentation API of the 'jhplot.math.StatisticSample' Java class
StatisticSample
jhplot.math

## Class StatisticSample

• `public class StatisticSampleextends Object`
A package to create random 1D and 2D arrays.
• ### Constructor Summary

Constructors
Constructor and Description
`StatisticSample()`
• ### Method Summary

All Methods
Modifier and TypeMethod and Description
`static double[][]``correlation(double[][] v)`
Correlation
`static double[][]``correlation(double[][] v1, double[][] v2)`
Correlation coefficient, covariance(v1, v2) / Math.sqrt(variance(v1) * variance(v2)
`static double``correlation(double[] v1, double[] v2)`
Correlation coefficient, covariance(v1, v2) / Math.sqrt(variance(v1) * variance(v2)
`static double[][]``covariance(double[][] v)`
Covariance
`static double[][]``covariance(double[][] v1, double[][] v2)`
Covariance
`static double``covariance(double[] v1, double[] v2)`
Covariance
`static double``mean(double[] v)`
Get mean value
`static double[]``mean(double[][] v)`
Get mean
`static double[]``randomBeta(int m, double a, double b)`
1D Random Beta distribution
`static double[][]``randomBeta(int m, int n, double a, double b)`
Random beata distribution
`static double[]``randomCauchy(int m, double mu, double sigma)`
1D Cauchy PDF
`static double[][]``randomCauchy(int m, int n, double mu, double sigma)`
2D Cauchy PDF
`static double[]``randomChi2(int m, int d)`
1D array with random numbers
`static double[][]``randomChi2(int m, int n, int d)`
2D array with Chi2
`static double[]``randomDirac(int m, double[] values, double[] prob)`
1D array with Dirac random values
`static double[][]``randomDirac(int m, int n, double[] values, double[] prob)`
2D array with Dirac random values
`double[][]``randomDoubleArray(int rows, int columns, AbstractDistribution dist)`
Build 2D integer array list with integer numbers from input random number generator
`DoubleArrayList``randomDoubleArrayList(int Ntot, AbstractDistribution dist)`
Build double array list with integer numbers from input random number generator
`static double[]``randomExponential(int m, double lambda)`
1D array with exponential numbers
`static double[][]``randomExponential(int m, int n, double lambda)`
2D array with exponential random distribution
`static int[]``randomInt(int m, int i0, int i1)`
Random array with integers
`static int[][]``randomInt(int m, int n, int i0, int i1)`
Random 2D array with integers
`int[]``randomIntArray(int Ntot, Binomial dist)`
Build integer array list with integer numbers from input random number generator
`int[][]``randomIntArray(int rows, int columns, AbstractDistribution dist)`
Build 2D integer array list with integer numbers from input random number generator
`IntArrayList``randomIntArrayList(int Ntot, AbstractDistribution dist)`
Build integer array list with integer numbers from input random number generator
`static double[]``randomLogNormal(int m, double mu, double sigma)`
1D array with random Log-normal values
`static double[][]``randomLogNormal(int m, int n, double mu, double sigma)`
2D Log-normal distribution
`static double[]``randomNormal(int m, double mu, double sigma)`
1D array with Gaussian numbers
`static double[][]``randomNormal(int m, int n, double mu, double sigma)`
2D array with Gaussian numbers
`static int[]``randomPoisson(int m, double mean)`
Build an array with Poisson distribution
`static double[]``randomRejection(int m, Expression fun, double maxFun, double min, double max)`
Build 1D array using analytic function.
`static double[][]``randomRejection(int m, int n, Expression fun, double maxFun, double min, double max)`
Build 2D random array using analytic function.
`static double[]``randomTriangular(int m, double min, double max)`
1D array with Triangular random PDF
`static double[]``randomTriangular(int m, double min, double med, double max)`
1D array for Triangular
`static double[][]``randomTriangular(int m, int n, double min, double max)`
2D array for Triangular random PDF
`static double[][]``randomTriangular(int m, int n, double min, double med, double max)`
2D array for Triangular
`static double[]``randomWeibull(int m, double lambda, double c)`
1D Weibull
`static double[][]``randomWeibull(int m, int n, double lambda, double c)`
2D Weibull
`static double[]``randUniform(int m, double min, double max)`
2D array with uniform values
`static double[][]``randUniform(int m, int n, double min, double max)`
2D array with random uniform values
`static double``stddeviation(double[] v)`
Standard deviation
`static double[]``stddeviation(double[][] v)`
Standard deviation
`static double``variance(double[] v)`
Variance
`static double[]``variance(double[][] v)`
Variance
• ### Methods inherited from class java.lang.Object

`equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`
• ### Constructor Detail

• #### StatisticSample

`public StatisticSample()`
• ### Method Detail

• #### randomInt

`public static int[][] randomInt(int m,                                int n,                                int i0,                                int i1)`
Random 2D array with integers
Parameters:
`m` - Rows
`n` - Columns
`i0` - Min value
`i1` - max value
Returns:
2D array
• #### randomInt

`public static int[] randomInt(int m,                              int i0,                              int i1)`
Random array with integers
Parameters:
`m` - array size
`i0` - min value
`i1` - max value
Returns:
array
• #### randUniform

`public static double[] randUniform(int m,                                   double min,                                   double max)`
2D array with uniform values
Parameters:
`m` - Total number
`min` - Min value
`max` - Max value
Returns:
array
• #### randUniform

`public static double[][] randUniform(int m,                                     int n,                                     double min,                                     double max)`
2D array with random uniform values
Parameters:
`m` - Rows
`n` - Columns
`min` - Min value
`max` - Max value
Returns:
array
• #### randomDirac

`public static double[][] randomDirac(int m,                                     int n,                                     double[] values,                                     double[] prob)`
2D array with Dirac random values
Parameters:
`m` - Rows
`n` - Columns
`values` - Values for function
`prob` - Probabilities
Returns:
array
• #### randomDirac

`public static double[] randomDirac(int m,                                   double[] values,                                   double[] prob)`
1D array with Dirac random values
Parameters:
`m` - Total number
`values` - array with values for the function
`prob` - probability
Returns:
array
• #### randomPoisson

`public static int[] randomPoisson(int m,                                  double mean)`
Build an array with Poisson distribution
Parameters:
`mean` - mean of Poisson distribution
• #### randomNormal

`public static double[][] randomNormal(int m,                                      int n,                                      double mu,                                      double sigma)`
2D array with Gaussian numbers
Parameters:
`m` - Rows
`n` - Columns
`mu` - mean
`sigma` - standard deviation
Returns:
array
• #### randomNormal

`public static double[] randomNormal(int m,                                    double mu,                                    double sigma)`
1D array with Gaussian numbers
Parameters:
`m` - Total number
`mu` - mean
`sigma` - standard deviation
Returns:
array
• #### randomChi2

`public static double[][] randomChi2(int m,                                    int n,                                    int d)`
2D array with Chi2
Parameters:
`m` - Rows
`n` - Columns
`d` - degrees of freedom
Returns:
array
• #### randomChi2

`public static double[] randomChi2(int m,                                  int d)`
1D array with random numbers
Parameters:
`m` - Total number
`d` - degree of freedoms
Returns:
array
• #### randomLogNormal

`public static double[][] randomLogNormal(int m,                                         int n,                                         double mu,                                         double sigma)`
2D Log-normal distribution
Parameters:
`m` - Rows
`n` - Columns
`mu` - mean
`sigma` - sigma
Returns:
array
• #### randomLogNormal

`public static double[] randomLogNormal(int m,                                       double mu,                                       double sigma)`
1D array with random Log-normal values
Parameters:
`m` - total number
`mu` - mean
`sigma` - sigma
Returns:
array
• #### randomExponential

`public static double[][] randomExponential(int m,                                           int n,                                           double lambda)`
2D array with exponential random distribution
Parameters:
`m` - Rows
`n` - Colums
`lambda` - lambda
Returns:
array
• #### randomExponential

`public static double[] randomExponential(int m,                                         double lambda)`
1D array with exponential numbers
Parameters:
`m` - total numbers
`lambda` - lambda
Returns:
array
• #### randomTriangular

`public static double[][] randomTriangular(int m,                                          int n,                                          double min,                                          double max)`
2D array for Triangular random PDF
Parameters:
`m` - Rows
`n` - Columns
`min` - Min
`max` - max
Returns:
array
• #### randomTriangular

`public static double[] randomTriangular(int m,                                        double min,                                        double max)`
1D array with Triangular random PDF
Parameters:
`m` - total number
`min` - Min
`max` - max
Returns:
array
• #### randomTriangular

`public static double[][] randomTriangular(int m,                                          int n,                                          double min,                                          double med,                                          double max)`
2D array for Triangular
Parameters:
`m` - Rows
`n` - Columns
`min` - Min
`med` - Median
`max` - Max
Returns:
array
• #### randomTriangular

`public static double[] randomTriangular(int m,                                        double min,                                        double med,                                        double max)`
1D array for Triangular
Parameters:
`m` - total number
`min` - Min
`med` - Median
`max` - Max
Returns:
array
• #### randomBeta

`public static double[][] randomBeta(int m,                                    int n,                                    double a,                                    double b)`
Random beata distribution
Parameters:
`m` - Rows
`n` - Columns
`a` - alpha
`b` - beta
Returns:
array
• #### randomBeta

`public static double[] randomBeta(int m,                                  double a,                                  double b)`
1D Random Beta distribution
Parameters:
`m` - total number
`a` - alpha
`b` - beta
Returns:
array
• #### randomCauchy

`public static double[][] randomCauchy(int m,                                      int n,                                      double mu,                                      double sigma)`
2D Cauchy PDF
Parameters:
`m` - Rows
`n` - Colums
`mu` - Mean
`sigma` - Sigma
Returns:
array
• #### randomCauchy

`public static double[] randomCauchy(int m,                                    double mu,                                    double sigma)`
1D Cauchy PDF
Parameters:
`m` - total number
`mu` - mean
`sigma` - sigma
Returns:
• #### randomWeibull

`public static double[][] randomWeibull(int m,                                       int n,                                       double lambda,                                       double c)`
2D Weibull
Parameters:
`m` - Rows
`n` - Columns
`lambda` - lambda
`c` - C
Returns:
array
• #### randomWeibull

`public static double[] randomWeibull(int m,                                     double lambda,                                     double c)`
1D Weibull
Parameters:
`m` - Rows
`lambda` - lambda
`c` - C
Returns:
array
• #### randomRejection

`public static double[][] randomRejection(int m,                                         int n,                                         Expression fun,                                         double maxFun,                                         double min,                                         double max)`
Build 2D random array using analytic function. First build F1D, than get parse (getParse()) and use it as input for this method.
Parameters:
`m` - Number of points
`fun` - ParseFunction (get it as getParse() for F1D)
`maxFun` - max of the function
`min` - Min value in X
`max` - Max value in X
• #### randomRejection

`public static double[] randomRejection(int m,                                       Expression fun,                                       double maxFun,                                       double min,                                       double max)`
Build 1D array using analytic function. First build F1D, than get parse (getParse()) and use it as input for this method.
Parameters:
`m` - Number of points
`fun` - ParseFunction (get it as getParse() for F1D)
`maxFun` - max of the function
`min` - Min value in X
`max` - Max value in X
• #### mean

`public static double mean(double[] v)`
Get mean value
Parameters:
`v` - vector
• #### mean

`public static double[] mean(double[][] v)`
Get mean
Parameters:
`v` - 2D array
Returns:
• #### stddeviation

`public static double stddeviation(double[] v)`
Standard deviation
Parameters:
`v` - vector
Returns:
• #### variance

`public static double variance(double[] v)`
Variance
Parameters:
`v` -
Returns:
vector
• #### stddeviation

`public static double[] stddeviation(double[][] v)`
Standard deviation
Parameters:
`v` -
Returns:
• #### variance

`public static double[] variance(double[][] v)`
Variance
Parameters:
`v` - vector
Returns:
• #### covariance

`public static double covariance(double[] v1,                                double[] v2)`
Covariance
Parameters:
`v1` - first vector
`v2` - second vector
Returns:
• #### covariance

`public static double[][] covariance(double[][] v1,                                    double[][] v2)`
Covariance
Parameters:
`v1` - first 2D array
`v2` - second 2D array
Returns:
• #### covariance

`public static double[][] covariance(double[][] v)`
Covariance
Parameters:
`v` -
Returns:
• #### correlation

`public static double correlation(double[] v1,                                 double[] v2)`
Correlation coefficient, covariance(v1, v2) / Math.sqrt(variance(v1) * variance(v2)
Parameters:
`v1` - first vector
`v2` - second vector
Returns:
• #### correlation

`public static double[][] correlation(double[][] v1,                                     double[][] v2)`
Correlation coefficient, covariance(v1, v2) / Math.sqrt(variance(v1) * variance(v2)
Parameters:
`v1` - first vector
`v2` - second vector
Returns:
• #### correlation

`public static double[][] correlation(double[][] v)`
Correlation
Parameters:
`v` -
Returns:
• #### randomIntArrayList

`public IntArrayList randomIntArrayList(int Ntot,                                       AbstractDistribution dist)`
Build integer array list with integer numbers from input random number generator
Parameters:
`Ntot` - total numbers
`dist` - input random number distribution
Returns:
array
• #### randomIntArray

`public int[] randomIntArray(int Ntot,                            Binomial dist)`
Build integer array list with integer numbers from input random number generator
Parameters:
`Ntot` - total numbers
`dist` - input random number distribution
Returns:
array
• #### randomIntArray

`public int[][] randomIntArray(int rows,                              int columns,                              AbstractDistribution dist)`
Build 2D integer array list with integer numbers from input random number generator
Parameters:
`rows` - rows
`colums` - columns
`dist` - input random number distribution
Returns:
array
• #### randomDoubleArray

`public double[][] randomDoubleArray(int rows,                                    int columns,                                    AbstractDistribution dist)`
Build 2D integer array list with integer numbers from input random number generator
Parameters:
`rows` - rows
`colums` - columns
`dist` - input random number distribution
Returns:
array
• #### randomDoubleArrayList

`public DoubleArrayList randomDoubleArrayList(int Ntot,                                             AbstractDistribution dist)`
Build double array list with integer numbers from input random number generator
Parameters:
`Ntot` -
`dist` -
Returns:
array

DMelt 1.2 © DataMelt by jWork.ORG

StatisticSample
jhplot.math

## Class StatisticSample

• `public class StatisticSampleextends Object`
A package to create random 1D and 2D arrays.

Warning: You cannot see the full API documentation of this class since the access to the DatMelt documentation for third-party Java classes is denied. Guests can only view jhplot Java API. To view the complete description of this class and its methods, please request the full DataMelt membership.

If you are already a full member, please login to the DataMelt member area before visiting this documentation.