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

      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 doublecorrelation(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 doublecovariance(double[] v1, double[] v2)
      Covariance
      static doublemean(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
      DoubleArrayListrandomDoubleArrayList(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
      IntArrayListrandomIntArrayList(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, Calculable fun, double maxFun, double min, double max)
      Build 1D array using analytic function.
      static double[][]randomRejection(int m, int n, Calculable 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 doublestddeviation(double[] v)
      Standard deviation
      static double[]stddeviation(double[][] v)
      Standard deviation
      static doublevariance(double[] v)
      Variance
      static double[]variance(double[][] v)
      Variance
    • 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,                         Calculable 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,                       Calculable 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

SCaVis 2.1 © jWork.ORG