程序包 org.hipparchus.stat.inference

类 InferenceTestUtils

java.lang.Object
org.hipparchus.stat.inference.InferenceTestUtils
public class InferenceTestUtils extends Object
一组静态方法，用于创建推断测试实例或执行推断测试。

  • 方法概要

    修饰符和类型
    方法
    说明
    static double
    approximateP(double d, int n, int m)
    使用Kolmogorov-Smirnov分布来近似\(P(D_{n,m} > d)\)，其中\(D_{n,m}\)是2样本Kolmogorov-Smirnov统计量。
    static double
    chiSquare(double[] expected, long[] observed)
    计算比较observed和expected频率计数的卡方统计量。
    static double
    chiSquare(long[][] counts)
    根据输入的counts数组（视为二维表）计算与卡方独立性检验相关的卡方统计量。
    static double
    chiSquareDataSetsComparison(long[] observed1, long[] observed2)
    计算比较observed1和observed2中的分箱频率计数的卡方双样本检验统计量。
    static double
    chiSquareTest(double[] expected, long[] observed)
    返回与observed频率计数与expected数组中的频率计数进行比较的卡方拟合优度检验相关的观察到的显著水平或p值。
    static boolean
    chiSquareTest(double[] expected, long[] observed, double alpha)
    执行评估观察计数是否符合由期望计数描述的频率分布的卡方拟合优度检验，显著水平为alpha的空假设。
    static double
    chiSquareTest(long[][] counts)
    返回基于输入的counts数组（视为二维表）进行的卡方独立性检验相关的观察到的显著水平或p值。
    static boolean
    chiSquareTest(long[][] counts, double alpha)
    执行评估输入的二维表中列中表示的分类是否独立于行的空假设的卡方独立性检验，显著水平为alpha。
    static double
    chiSquareTestDataSetsComparison(long[] observed1, long[] observed2)
    返回比较observed1和observed2中的分箱频率计数的卡方双样本检验相关的观察到的显著水平或p值。
    static boolean
    chiSquareTestDataSetsComparison(long[] observed1, long[] observed2, double alpha)
    执行比较两个分箱数据集的卡方双样本检验。
    static double
    exactP(double d, int m, int n, boolean strict)
    如果strict为true，则计算\(P(D_{n,m} > d)\)；否则计算\(P(D_{n,m} \ge d)\)，其中\(D_{n,m}\)是2样本Kolmogorov-Smirnov统计量。
    static double
    g(double[] expected, long[] observed)
    计算比较observed和expected频率计数的拟合优度G统计量。
    static double
    gDataSetsComparison(long[] observed1, long[] observed2)
    计算比较observed1和observed2中频率计数的独立性的G（对数似然比）双样本检验统计量。
    static double
    gTest(double[] expected, long[] observed)
    返回与比较observed频率计数与expected数组中的频率计数的G-拟合优度检验相关的观察到的显著水平或p值。
    static boolean
    gTest(double[] expected, long[] observed, double alpha)
    执行评估观察计数是否符合由期望计数描述的频率分布的G-拟合优度检验，显著水平为alpha的空假设。
    static double
    gTestDataSetsComparison(long[] observed1, long[] observed2)
    返回与比较observed1和observed2中分箱频率计数的G-值（对数似然比）双样本检验相关的观察到的显著水平或p值。
    static boolean
    gTestDataSetsComparison(long[] observed1, long[] observed2, double alpha)
    执行比较两个分箱数据集的G-值（对数似然比）双样本检验。
    static double
    gTestIntrinsic(double[] expected, long[] observed)
    返回固有的（Hardy-Weinberg比例）p值，如McDonald, J.H. 2009中的p64-69所述。
    static double
    homoscedasticT(double[] sample1, double[] sample2)
    在等子群方差相等的假设下计算2样本t统计量。
    static double
    homoscedasticT(StatisticalSummary sampleStats1, StatisticalSummary sampleStats2)
    在假设子群方差相等的情况下，比较由两个StatisticalSummary实例描述的数据集的均值的2样本t统计量。
    static double
    homoscedasticTTest(double[] sample1, double[] sample2)
    返回与假设两个样本来自具有相等方差的子群的总体的两样本、双尾t检验相关的观察到的显著水平或p值，假设两个样本是从具有相等方差的子群中抽取的。
    static boolean
    homoscedasticTTest(double[] sample1, double[] sample2, double alpha)
    执行评估空假设，即sample1和sample2来自具有相同均值的总体，显著水平为alpha的双侧t检验。
    static double
    homoscedasticTTest(StatisticalSummary sampleStats1, StatisticalSummary sampleStats2)
    返回与假设两个样本是从具有相等子群方差的总体中抽取的，基于由两个StatisticalSummary实例描述的数据集的均值的两样本、双尾t检验相关的观察到的显著水平或p值。
    static double
    kolmogorovSmirnovStatistic(double[] x, double[] y)
    计算两样本Kolmogorov-Smirnov检验统计量，\(D_{n,m}=\sup_x |F_n(x)-F_m(x)|\)，其中\(n\)是x的长度，\(m\)是y的长度，\(F_n\)是将质量\(1/n\)放在x值中的经验分布，\(F_m\)是y值的经验分布。
    static double
    kolmogorovSmirnovStatistic(RealDistribution dist, double[] data)
    计算一样本Kolmogorov-Smirnov检验统计量，\(D_n=\sup_x |F_n(x)-F(x)|\)，其中\(F\)是与distribution相关的分布（cdf）函数，\(n\)是data的长度，\(F_n\)是将质量\(1/n\)放在data值中的经验分布。
    static double
    kolmogorovSmirnovTest(double[] x, double[] y)
    计算两样本Kolmogorov-Smirnov检验的p值，评估x和y是否来自相同的概率分布的空假设。
    static double
    kolmogorovSmirnovTest(double[] x, double[] y, boolean strict)
    计算两样本Kolmogorov-Smirnov检验的p值，评估x和y是否来自相同的概率分布的空假设。
    static double
    kolmogorovSmirnovTest(RealDistribution dist, double[] data)
    计算一样本Kolmogorov-Smirnov检验的p值，评估data是否符合distribution的空假设。
    static double
    kolmogorovSmirnovTest(RealDistribution dist, double[] data, boolean strict)
    计算一样本Kolmogorov-Smirnov检验的p值，评估data是否符合distribution的空假设。
    static boolean
    kolmogorovSmirnovTest(RealDistribution dist, double[] data, double alpha)
    执行评估data是否符合distribution的Kolmogorov-Smirnov检验。
    static double
    oneWayAnovaFValue(Collection<double[]> categoryData)
    计算一组double[]数组的ANOVA F值。
    static double
    oneWayAnovaPValue(Collection<double[]> categoryData)
    计算一组double[]数组的ANOVA P值。
    static boolean
    oneWayAnovaTest(Collection<double[]> categoryData, double alpha)
    执行ANOVA检验，评估数据类别的均值之间是否存在差异的空假设。
    static double
    pairedT(double[] sample1, double[] sample2)
    基于输入数组中的数据计算配对的2样本t统计量。
    static double
    pairedTTest(double[] sample1, double[] sample2)
    返回基于输入数组中的数据进行的配对、两样本、双尾t检验的观察到的显著水平或p值。
    static boolean
    pairedTTest(double[] sample1, double[] sample2, double alpha)
    执行配对t检验，评估sample1和sample2之间的配对差异均值是否为0，以支持均值配对差异不等于0的双侧备择假设，显著水平为alpha。
    static double
    rootLogLikelihoodRatio(long k11, long k12, long k21, long k22)
    计算两个状态数据集的根对数似然比。
    static double
    t(double[] sample1, double[] sample2)
    计算不假设子群方差相等的情况下的2样本t统计量。
    static double
    t(double mu, double[] observed)
    根据观察值和比较常数计算t统计量。
    static double
    t(double mu, StatisticalSummary sampleStats)
    计算用于将由sampleStats描述的数据集的均值与mu进行比较的t统计量。
    static double
    t(StatisticalSummary sampleStats1, StatisticalSummary sampleStats2)
    计算两个StatisticalSummary实例描述的数据集的均值的2样本t统计量，不假设子总体方差相等。
    static double
    tTest(double[] sample1, double[] sample2)
    返回与比较输入数组均值的两样本、双尾t检验相关的观察显著水平或p值。
    static boolean
    tTest(double[] sample1, double[] sample2, double alpha)
    执行双侧t检验，评估sample1和sample2来自具有相同均值的总体的零假设，显著水平为alpha。
    static double
    tTest(double mu, double[] sample)
    返回与将输入数组均值与常数mu进行双样本、双尾t检验相关的观察显著水平或p值。
    static boolean
    tTest(double mu, double[] sample, double alpha)
    执行双侧t检验，评估sample所绘制的总体的均值是否等于mu的零假设。
    static double
    tTest(double mu, StatisticalSummary sampleStats)
    返回与将由sampleStats描述的数据集的均值与常数mu进行单样本、双尾t检验相关的观察显著水平或p值。
    static boolean
    tTest(double mu, StatisticalSummary sampleStats, double alpha)
    执行双侧t检验，评估由stats描述的数据集所绘制的总体的均值是否等于mu的零假设。
    static double
    tTest(StatisticalSummary sampleStats1, StatisticalSummary sampleStats2)
    返回与比较由两个StatisticalSummary实例描述的数据集的均值的两样本、双尾t检验相关的观察显著水平或p值。
    static boolean
    tTest(StatisticalSummary sampleStats1, StatisticalSummary sampleStats2, double alpha)
    执行双侧t检验，评估sampleStats1和sampleStats2描述的数据集是否来自具有相同均值的总体的零假设，显著水平为alpha。

    从类继承的方法 java.lang.Object

    clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

  • 方法详细资料

    • homoscedasticT

      public static double homoscedasticT(double[] sample1, double[] sample2) throws MathIllegalArgumentException, NullArgumentException
      在等子总体方差的假设下计算2样本t统计量。要计算不考虑相等方差假设的t统计量，请使用t(double[], double[])。

      此统计量可用于执行（同方差）双样本t检验以比较样本均值。

      t统计量为

         t = (m1 - m2) / (sqrt(1/n1 +1/n2) sqrt(var))

      其中n1是第一个样本的大小；n2是第二个样本的大小；m1是第一个样本的均值；m2是第二个样本的均值，var是合并方差估计：

      var = sqrt(((n1 - 1)var1 + (n2 - 1)var2) / ((n1-1) + (n2-1)))

      其中var1是第一个样本的方差，var2是第二个样本的方差。

      前提条件：

      • 观察到的数组长度必须至少为2。
      参数:
      sample1 - 样本数据值数组
      sample2 - 样本数据值数组
      返回:
      t统计量
      抛出:
      NullArgumentException - 如果数组为null
      MathIllegalArgumentException - 如果数组长度< 2

    • homoscedasticT

      public static double homoscedasticT(StatisticalSummary sampleStats1, StatisticalSummary sampleStats2) throws MathIllegalArgumentException, NullArgumentException
      在等子总体方差的假设下，计算由两个StatisticalSummary实例描述的数据集的均值的2样本t统计量。要计算不考虑相等方差假设的t统计量，请使用t(StatisticalSummary, StatisticalSummary)。

      此统计量可用于执行（同方差）双样本t检验以比较样本均值。

      返回的t统计量为

         t = (m1 - m2) / (sqrt(1/n1 +1/n2) sqrt(var))

      其中n1是第一个样本的大小；n2是第二个样本的大小；m1是第一个样本的均值；m2是第二个样本的均值，var是合并方差估计：

      var = sqrt(((n1 - 1)var1 + (n2 - 1)var2) / ((n1-1) + (n2-1)))

      其中var1是第一个样本的方差，var2是第二个样本的方差。

      前提条件：

      • 由两个Univariates描述的数据集必须至少包含2个观测值。
      参数:
      sampleStats1 - 描述第一个样本数据的StatisticalSummary
      sampleStats2 - 描述第二个样本数据的StatisticalSummary
      返回:
      t统计量
      抛出:
      NullArgumentException - 如果样本统计数据为null
      MathIllegalArgumentException - 如果样本数量< 2

    • homoscedasticTTest

      public static boolean homoscedasticTTest(double[] sample1, double[] sample2, double alpha) throws MathIllegalArgumentException, NullArgumentException, MathIllegalStateException
      执行双侧t检验，评估sample1和sample2来自具有相同均值的子总体的零假设，显著水平为alpha，假设子总体方差相等。使用tTest(double[], double[], double)来执行不考虑方差相等假设的检验。

      如果可以以置信度1 - alpha拒绝均值相等的零假设，则返回true。要执行单侧检验，请使用alpha * 2.要执行不考虑相等子总体方差假设的检验，请使用tTest(double[], double[], double)。

      使用合并方差估计来计算t统计量。有关公式，请参见t(double[], double[])。样本大小之和减2用作自由度。

      示例：

      1. 要在95%水平上测试（双侧）假设mean 1 = mean 2 ，请使用
        tTest(sample1, sample2, 0.05).
      2. 要在99%水平上测试（单侧）假设 mean 1 < mean 2, ，首先验证sample 1的测量均值是否小于sample 2的均值，然后使用
        tTest(sample1, sample2, 0.02)

      使用说明：
      测试的有效性取决于参数t检验过程的假设，如此处讨论的这里

      前提条件：

      • 观察到的数组长度必须至少为2。
      • 0 < alpha < 0.5
      参数:
      sample1 - 样本数据值数组
      sample2 - 样本数据值数组
      alpha - 检验的显著水平
      返回:
      如果可以以置信度1 - alpha拒绝均值相等的零假设，则为true
      抛出:
      NullArgumentException - 如果数组为null
      MathIllegalArgumentException - 如果数组长度< 2
      MathIllegalArgumentException - 如果alpha不在范围(0, 0.5]
      MathIllegalStateException - 如果计算p值时发生错误

    • homoscedasticTTest

      public static double homoscedasticTTest(double[] sample1, double[] sample2) throws MathIllegalArgumentException, NullArgumentException, MathIllegalStateException
      返回与假设两个样本来自具有相等方差的子总体的情况下，比较输入数组均值的两样本、双尾t检验相关的观察显著水平或p值。要执行不考虑相等方差假设的检验，请使用tTest(double[], double[])。

      返回的数字是可以拒绝两个均值相等的零假设，支持它们不同的双侧备择假设的最小显著水平。对于单侧检验，将返回值除以2。

      使用合并方差估计来计算t统计量。有关公式，请参见homoscedasticT(double[], double[])。样本大小之和减2用作自由度。

      使用说明：
      p值的有效性取决于参数t检验过程的假设，如此处讨论的这里

      前提条件：

      • 观察到的数组长度必须至少为2。
      参数:
      sample1 - 样本数据值数组
      sample2 - 样本数据值数组
      返回:
      t检验的p值
      抛出:
      NullArgumentException - 如果数组为null
      MathIllegalArgumentException - 如果数组长度< 2
      MathIllegalStateException - 如果计算p值时发生错误

    • homoscedasticTTest

      public static double homoscedasticTTest(StatisticalSummary sampleStats1, StatisticalSummary sampleStats2) throws MathIllegalArgumentException, NullArgumentException, MathIllegalStateException
      返回两个StatisticalSummary实例描述的数据集的均值进行双样本、双尾t检验的观察显著性水平或p值，在等子总体方差假设下。要执行不等方差假设的检验，请使用tTest(StatisticalSummary, StatisticalSummary)。

      返回的数字是可以拒绝零假设（两个均值相等）的最小显著性水平，支持双侧备择假设（两者不同）。对于单侧检验，将返回值除以2。

      查看homoscedasticT(double[], double[])以计算t统计量的公式。样本大小之和减2用作自由度。

      使用注意：
      p值的有效性取决于参数t检验程序的假设，如此处讨论的链接

      前提条件：

      • 两个Univariates描述的数据集必须至少包含2个观测值。
      参数:
      sampleStats1 - 描述第一个样本数据的StatisticalSummary
      sampleStats2 - 描述第二个样本数据的StatisticalSummary
      返回:
      t检验的p值
      抛出:
      NullArgumentException - 如果样本统计数据为null
      MathIllegalArgumentException - 如果样本数量小于2
      MathIllegalStateException - 如果计算p值时出现错误

    • pairedT

      public static double pairedT(double[] sample1, double[] sample2) throws MathIllegalArgumentException, NullArgumentException
      根据输入数组中的数据，计算成对的双样本t统计量。返回的t统计量等同于计算单样本t统计量t(double, double[])，其中mu = 0，样本数组由sample1和sample2中对应条目的（有符号的）差异组成。

      前提条件：

      • 输入数组必须具有相同长度，且它们的共同长度必须至少为2。
      参数:
      sample1 - 样本数据值数组
      sample2 - 样本数据值数组
      返回:
      t统计量
      抛出:
      NullArgumentException - 如果数组为null
      MathIllegalArgumentException - 如果数组为空
      MathIllegalArgumentException - 如果数组长度不相等
      MathIllegalArgumentException - 如果数组长度小于2

    • pairedTTest

      public static boolean pairedTTest(double[] sample1, double[] sample2, double alpha) throws MathIllegalArgumentException, NullArgumentException, MathIllegalStateException
      执行成对t检验，评估假设成对差异的均值为0，支持成对差异均值不等于0的双侧备择假设，显著性水平为alpha。

      如果可以以置信度1 - alpha拒绝零假设，则返回true。要执行单侧检验，使用alpha * 2

      使用注意：
      测试的有效性取决于参数t检验程序的假设，如此处讨论的链接

      前提条件：

      • 输入数组长度必须相同，且它们的共同长度必须至少为2。
      • 0 < alpha < 0.5
      参数:
      sample1 - 样本数据值数组
      sample2 - 样本数据值数组
      alpha - 测试的显著性水平
      返回:
      如果可以以置信度1 - alpha拒绝零假设，则为true
      抛出:
      NullArgumentException - 如果数组为null
      MathIllegalArgumentException - 如果数组为空
      MathIllegalArgumentException - 如果数组长度不相等
      MathIllegalArgumentException - 如果数组长度小于2
      MathIllegalArgumentException - 如果alpha不在范围(0, 0.5]内
      MathIllegalStateException - 如果计算p值时出现错误

    • pairedTTest

      public static double pairedTTest(double[] sample1, double[] sample2) throws MathIllegalArgumentException, NullArgumentException, MathIllegalStateException
      返回基于输入数组中的数据进行成对的双样本双尾t检验的观察显著性水平或p值。

      返回的数字是可以拒绝成对差异均值为0的零假设的最小显著性水平，支持成对差异均值不等于0的双侧备择假设。对于单侧检验，将返回值除以2。

      此检验等同于使用tTest(double, double[])计算的单样本t检验，其中mu = 0，样本数组由sample1和sample2中对应元素的有符号差异组成。

      使用注意：
      p值的有效性取决于参数t检验程序的假设，如此处讨论的链接

      前提条件：

      • 输入数组长度必须相同，且它们的共同长度必须至少为2。
      参数:
      sample1 - 样本数据值数组
      sample2 - 样本数据值数组
      返回:
      t检验的p值
      抛出:
      NullArgumentException - 如果数组为null
      MathIllegalArgumentException - 如果数组为空
      MathIllegalArgumentException - 如果数组长度不相等
      MathIllegalArgumentException - 如果数组长度小于2
      MathIllegalStateException - 如果计算p值时出现错误

    • t

      public static double t(double mu, double[] observed) throws MathIllegalArgumentException, NullArgumentException
      给定观察值和比较常数，计算t统计量。

      此统计量可用于执行均值的单样本t检验。

      前提条件：

      • 观察数组长度必须至少为2。
      参数:
      mu - 比较常数
      observed - 值数组
      返回:
      t统计量
      抛出:
      NullArgumentException - 如果observed为null
      MathIllegalArgumentException - 如果observed的长度小于2

    • t

      public static double t(double mu, StatisticalSummary sampleStats) throws MathIllegalArgumentException, NullArgumentException
      计算用于将sampleStats描述的数据集的均值与mu进行比较的t统计量。

      此统计量可用于执行均值的单样本t检验。

      前提条件：

      • observed.getN() ≥ 2。
      参数:
      mu - 比较常数
      sampleStats - 包含样本摘要统计信息的DescriptiveStatistics
      返回:
      t统计量
      抛出:
      NullArgumentException - 如果sampleStats为null
      MathIllegalArgumentException - 如果样本数量小于2

    • t

      public static double t(double[] sample1, double[] sample2) throws MathIllegalArgumentException, NullArgumentException
      计算双样本t统计量，不假设等子总体方差。要假设等方差计算t统计量，请使用homoscedasticT(double[], double[])。

      此统计量可用于执行双样本t检验以比较样本均值。

      t统计量为

         t = (m1 - m2) / sqrt(var1/n1 + var2/n2)

      其中n1是第一个样本的大小，n2是第二个样本的大小；m1是第一个样本的均值；m2是第二个样本的均值；var1是第一个样本的方差；var2是第二个样本的方差；

      前提条件：

      • 观察数组长度必须都至少为2。
      参数:
      sample1 - 样本数据值数组
      sample2 - 样本数据值数组
      返回:
      t统计量
      抛出:
      NullArgumentException - 如果数组为null
      MathIllegalArgumentException - 如果数组长度< 2

    • t

      public static double t(StatisticalSummary sampleStats1, StatisticalSummary sampleStats2) throws MathIllegalArgumentException, NullArgumentException
      计算2样本t统计量，比较由两个StatisticalSummary实例描述的数据集的均值，不假设子总体方差相等。使用homoscedasticT(StatisticalSummary, StatisticalSummary)来在等方差假设下计算t统计量。

      此统计量可用于执行双样本t检验以比较样本均值。

      返回的t统计量为

         t = (m1 - m2) / sqrt(var1/n1 + var2/n2)

      其中n1是第一个样本的大小； n2是第二个样本的大小； m1是第一个样本的均值； m2是第二个样本的均值； var1是第一个样本的方差； var2是第二个样本的方差

      前提条件：

      • 由两个Univariates描述的数据集必须至少包含2个观测值。
      参数:
      sampleStats1 - 描述第一个样本数据的StatisticalSummary
      sampleStats2 - 描述第二个样本数据的StatisticalSummary
      返回:
      t统计量
      抛出:
      NullArgumentException - 如果样本统计数据为null
      MathIllegalArgumentException - 如果样本数量< 2

    • tTest

      public static boolean tTest(double mu, double[] sample, double alpha) throws MathIllegalArgumentException, NullArgumentException, MathIllegalStateException
      执行双侧t检验，评估从sample抽取的总体均值等于mu的零假设。

      返回true，当且仅当可以以置信度1 - alpha拒绝零假设。要执行单侧检验，请使用alpha * 2

      示例：

      1. 要在95%水平下测试（双侧）假设样本均值 = mu ，使用
        tTest(mu, sample, 0.05)
      2. 要在99%水平下测试（单侧）假设 样本均值 < mu ，首先验证测得的样本均值是否小于mu，然后使用
        tTest(mu, sample, 0.02)

      使用说明：
      测试的有效性取决于单样本参数t检验程序的假设，如此处讨论的这里

      前提条件：

      • 观察数组长度必须至少为2。
      参数:
      mu - 与样本均值比较的常数值
      sample - 样本数据值数组
      alpha - 测试的显著性水平
      返回:
      p值
      抛出:
      NullArgumentException - 如果样本数组为null
      MathIllegalArgumentException - 如果数组长度< 2
      MathIllegalArgumentException - 如果alpha不在范围(0, 0.5]内
      MathIllegalStateException - 如果计算p值时出现错误

    • tTest

      public static double tTest(double mu, double[] sample) throws MathIllegalArgumentException, NullArgumentException, MathIllegalStateException
      返回与一样本双侧t检验相关的观察到的显著性水平或p值，比较输入数组的均值与常数mu。

      返回的数字是可以拒绝均值等于mu的零假设的最小显著性水平，以支持均值与mu不同的双侧备择假设。对于单侧检验，将返回值除以2。

      使用说明：
      测试的有效性取决于参数t检验程序的假设，如此处讨论的这里

      前提条件：

      • 观察数组长度必须至少为2。
      参数:
      mu - 与样本均值比较的常数值
      sample - 样本数据值数组
      返回:
      p值
      抛出:
      NullArgumentException - 如果样本数组为null
      MathIllegalArgumentException - 如果数组长度< 2
      MathIllegalStateException - 如果计算p值时出现错误

    • tTest

      public static boolean tTest(double mu, StatisticalSummary sampleStats, double alpha) throws MathIllegalArgumentException, NullArgumentException, MathIllegalStateException
      执行双侧t检验，评估由stats描述的数据集抽取的总体均值等于mu的零假设。

      返回true，当且仅当可以以置信度1 - alpha拒绝零假设。要执行单侧检验，请使用alpha * 2.

      示例：

      1. 要在95%水平下测试（双侧）假设样本均值 = mu ，使用
        tTest(mu, sampleStats, 0.05)
      2. 要在99%水平下测试（单侧）假设 样本均值 < mu ，首先验证测得的样本均值是否小于mu，然后使用
        tTest(mu, sampleStats, 0.02)

      使用说明：
      测试的有效性取决于参数t检验程序的假设，如此处讨论的这里

      前提条件：

      • 样本必须包含至少2个观测值。
      参数:
      mu - 与样本均值比较的常数值
      sampleStats - 描述样本数据值的StatisticalSummary
      alpha - 测试的显著性水平
      返回:
      p值
      抛出:
      NullArgumentException - 如果sampleStats为null
      MathIllegalArgumentException - 如果样本数量< 2
      MathIllegalArgumentException - 如果alpha不在范围(0, 0.5]内
      MathIllegalStateException - 如果计算p值时出现错误

    • tTest

      public static double tTest(double mu, StatisticalSummary sampleStats) throws MathIllegalArgumentException, NullArgumentException, MathIllegalStateException
      返回与由sampleStats描述的数据集的均值与常数mu进行一样本双侧t检验相关的观察到的显著性水平或p值。

      返回的数字是可以拒绝均值等于mu的零假设的最小显著性水平，以支持均值与mu不同的双侧备择假设。对于单侧检验，将返回值除以2。

      使用说明：
      测试的有效性取决于参数t检验程序的假设，如此处讨论的这里

      前提条件：

      • 样本必须包含至少2个观测值。
      参数:
      mu - 与样本均值比较的常数值
      sampleStats - 描述样本数据的StatisticalSummary
      返回:
      p值
      抛出:
      NullArgumentException - 如果sampleStats为null
      MathIllegalArgumentException - 如果样本数量< 2
      MathIllegalStateException - 如果计算p值时出现错误

    • tTest

      public static boolean tTest(double[] sample1, double[] sample2, double alpha) throws MathIllegalArgumentException, NullArgumentException, MathIllegalStateException
      执行双侧t检验，评估sample1和sample2来自具有相同均值的总体的零假设，显著性水平为alpha。此检验不假设子总体方差相等。要执行假设方差相等的检验，请使用homoscedasticTTest(double[], double[], double)。

      返回true，当可以有信心拒绝均值相等的零假设时，置信度为1 - alpha。要执行单侧检验，请使用alpha * 2

      查看t(double[], double[])以计算t统计量所使用的公式。自由度使用韦尔奇-萨特斯韦特近似进行估算。

      示例：

      1. 要在95%水平上测试（双侧）假设均值1 = 均值2，使用
        tTest(sample1, sample2, 0.05)
      2. 要在99%水平上测试（单侧）假设均值1 < 均值2，首先验证sample 1的测量均值是否小于sample 2的均值，然后使用
        tTest(sample1, sample2, 0.02)

      使用注意：
      测试的有效性取决于参数t检验过程的假设，如此处所述这里

      前提条件：

      • 观察到的数组长度必须至少为2。
      • 0 < alpha < 0.5
      参数:
      sample1 - 样本数据值数组
      sample2 - 样本数据值数组
      alpha - 测试的显著性水平
      返回:
      如果可以有信心拒绝均值相等的零假设，则为true
      抛出:
      NullArgumentException - 如果数组为null
      MathIllegalArgumentException - 如果数组长度<2
      MathIllegalArgumentException - 如果alpha不在范围(0, 0.5]
      MathIllegalStateException - 如果计算p值时发生错误

    • tTest

      public static double tTest(double[] sample1, double[] sample2) throws MathIllegalArgumentException, NullArgumentException, MathIllegalStateException
      返回与两个输入数组的均值进行比较的双样本、双侧t检验相关的观察到的显著性水平或p值。

      返回的数字是可以拒绝两个均值相等的零假设的最小显著性水平，支持它们不同的双侧备择假设。对于单侧检验，将返回值除以2。

      该检验不假设基础总体方差相等，并使用从样本数据计算的近似自由度来计算p值。使用的t统计量如t(double[], double[])中定义的，并使用韦尔奇-萨特斯韦特近似来计算自由度，如此处描述这里。要在假设方差相等的情况下执行检验，请使用homoscedasticTTest(double[], double[])。

      使用注意：
      p值的有效性取决于参数t检验过程的假设，如此处所述这里

      前提条件：

      • 观察到的数组长度必须至少为2。
      参数:
      sample1 - 样本数据值数组
      sample2 - 样本数据值数组
      返回:
      t检验的p值
      抛出:
      NullArgumentException - 如果数组为null
      MathIllegalArgumentException - 如果数组长度<2
      MathIllegalStateException - 如果计算p值时发生错误

    • tTest

      public static boolean tTest(StatisticalSummary sampleStats1, StatisticalSummary sampleStats2, double alpha) throws MathIllegalArgumentException, NullArgumentException, MathIllegalStateException
      执行双侧t检验，评估sampleStats1和sampleStats2描述的数据集来自具有相同均值的总体的零假设，显著性水平为alpha。此检验不假设子总体方差相等。要在假设方差相等的情况下执行检验，请使用homoscedasticTTest(StatisticalSummary, StatisticalSummary)。

      返回true，当可以有信心拒绝均值相等的零假设时，置信度为1 - alpha。要执行单侧检验，请使用alpha * 2

      查看t(double[], double[])以计算t统计量所使用的公式。自由度使用韦尔奇-萨特斯韦特近似进行估算。

      示例：

      1. 要在95%水平上测试（双侧）假设均值1 = 均值2，使用
        tTest(sampleStats1, sampleStats2, 0.05)
      2. 要在99%水平上测试（单侧）假设均值1 < 均值2，首先验证sample 1的测量均值是否小于sample 2的均值，然后使用
        tTest(sampleStats1, sampleStats2, 0.02)

      使用注意：
      测试的有效性取决于参数t检验过程的假设，如此处所述这里

      前提条件：

      • 由两个Univariates描述的数据集必须至少包含2个观测值。
      • 0 < alpha < 0.5
      参数:
      sampleStats1 - 描述样本数据值的StatisticalSummary
      sampleStats2 - 描述样本数据值的StatisticalSummary
      alpha - 测试的显著性水平
      返回:
      如果可以有信心拒绝均值相等的零假设，则为true
      抛出:
      NullArgumentException - 如果样本统计数据为null
      MathIllegalArgumentException - 如果样本数<2
      MathIllegalArgumentException - 如果alpha不在范围(0, 0.5]
      MathIllegalStateException - 如果计算p值时发生错误

    • tTest

      public static double tTest(StatisticalSummary sampleStats1, StatisticalSummary sampleStats2) throws MathIllegalArgumentException, NullArgumentException, MathIllegalStateException
      返回与两个StatisticalSummary实例描述的数据集的均值进行比较的双样本、双侧t检验相关的观察到的显著性水平或p值。

      返回的数字是可以拒绝两个均值相等的零假设的最小显著性水平，支持它们不同的双侧备择假设。对于单侧检验，将返回值除以2。

      该检验不假设基础总体方差相等，并使用从样本数据计算的近似自由度来计算p值。要执行假设方差相等的检验，请使用homoscedasticTTest(StatisticalSummary, StatisticalSummary)。

      使用注意：
      p值的有效性取决于参数t检验过程的假设，如此处所述这里

      前提条件：

      • 由两个Univariates描述的数据集必须至少包含2个观测值。
      参数:
      sampleStats1 - 描述第一个样本数据的StatisticalSummary
      sampleStats2 - 描述第二个样本数据的StatisticalSummary
      返回:
      t检验的p值
      抛出:
      NullArgumentException - 如果样本统计数据为null
      MathIllegalArgumentException - 如果样本数<2
      MathIllegalStateException - 如果计算p值时发生错误

    • chiSquare

      public static double chiSquare(double[] expected, long[] observed) throws MathIllegalArgumentException
      计算比较observed和expected频率计数的卡方统计量。

      此统计量可用于执行卡方检验，评估观察计数是否遵循预期分布的零假设。

      前提条件：

      • 预期计数必须全部为正数。
      • 观察计数必须全部≥ 0。
      • 观察和预期数组必须具有相同长度，它们的共同长度必须至少为2。

      如果不满足任何前提条件，则会抛出IllegalArgumentException。

      注意：此实现会根据需要重新调整expected数组，以确保预期计数和观察计数的总和相等。

      参数:
      expected - 预期频率计数的数组
      observed - 观察到的频率计数的数组
      返回:
      卡方检验统计量
      抛出:
      MathIllegalArgumentException - 如果observed具有负条目
      MathIllegalArgumentException - 如果expected具有不严格正条目
      MathIllegalArgumentException - 如果数组长度小于2

    • chiSquare

      public static double chiSquare(long[][] counts) throws MathIllegalArgumentException, NullArgumentException
      计算与输入counts数组相关的卡方统计量，将其视为二维表的卡方独立性检验。

      2维表的行是count[0], ... , count[count.length - 1]

      前提条件:

      • 所有计数必须≥ 0。
      • 计数数组必须是矩形的（即所有count[i]子数组的长度必须相同）。
      • 由counts表示的2维表必须至少有2列和至少2行。

      如果不满足任何前提条件，则会抛出IllegalArgumentException。

      参数:
      counts - 2维表的数组表示
      返回:
      卡方检验统计量
      抛出:
      NullArgumentException - 如果数组为null
      MathIllegalArgumentException - 如果数组不是矩形的
      MathIllegalArgumentException - 如果counts具有负条目

    • chiSquareTest

      public static boolean chiSquareTest(double[] expected, long[] observed, double alpha) throws MathIllegalArgumentException, MathIllegalStateException
      执行卡方拟合优度检验，评估观察计数是否符合由预期计数描述的频率分布的零假设，显著性水平为alpha。如果可以以100 *（1 - alpha）百分比的置信度拒绝零假设，则返回true。

      示例:
      要测试观察值observed是否在99%水平上遵循expected的假设，请使用chiSquareTest(expected, observed, 0.01)

      前提条件:

      • 预期计数必须全部为正数。
      • 观察计数必须全部≥ 0。
      • 观察和预期数组必须具有相同的长度，它们的共同长度必须至少为2。
      • 0 < alpha < 0.5

      如果不满足任何前提条件，则会抛出IllegalArgumentException。

      注意: 如果需要，此实现将重新调整expected数组，以确保预期计数和观察计数的总和相等。

      参数:
      expected - 预期频率计数的数组
      observed - 观察到的频率计数的数组
      alpha - 测试的显著性水平
      返回:
      如果可以以置信度1 - alpha拒绝零假设，则为true
      抛出:
      MathIllegalArgumentException - 如果observed具有负条目
      MathIllegalArgumentException - 如果expected具有不严格正条目
      MathIllegalArgumentException - 如果数组长度小于2
      MathIllegalArgumentException - 如果alpha不在范围（0, 0.5]内
      MathIllegalStateException - 如果计算p值时发生错误

    • chiSquareTest

      public static double chiSquareTest(double[] expected, long[] observed) throws MathIllegalArgumentException, MathIllegalStateException
      返回与observed频率计数与expected数组中描述的频率分布相符的观察到的显著性水平，或p值。

      返回的数字是可以拒绝观察计数符合由预期计数描述的频率分布的零假设的最小显著性水平。

      前提条件:

      • 预期计数必须全部为正数。
      • 观察计数必须全部≥ 0。
      • 观察和预期数组必须具有相同的长度，它们的共同长度必须至少为2。

      如果不满足任何前提条件，则会抛出IllegalArgumentException。

      注意: 如果需要，此实现将重新调整expected数组，以确保预期计数和观察计数的总和相等。

      参数:
      expected - 预期频率计数的数组
      observed - 观察到的频率计数的数组
      返回:
      p值
      抛出:
      MathIllegalArgumentException - 如果observed具有负条目
      MathIllegalArgumentException - 如果expected具有不严格正条目
      MathIllegalArgumentException - 如果数组长度小于2
      MathIllegalStateException - 如果计算p值时发生错误

    • chiSquareTest

      public static boolean chiSquareTest(long[][] counts, double alpha) throws MathIllegalArgumentException, NullArgumentException, MathIllegalStateException
      执行卡方独立性检验，评估输入2维表的列中计数所代表的分类是否独立于行的零假设，显著性水平为alpha。如果可以以100 *（1 - alpha）百分比的置信度拒绝零假设，则返回true。

      2维表的行是count[0], ... , count[count.length - 1]

      示例:
      要在99%水平上测试count[0], ... , count[count.length - 1] 中的计数是否都对应于相同的潜在概率分布，请使用chiSquareTest(counts, 0.01)。

      前提条件:

      • 所有计数必须≥ 0。
      • 计数数组必须是矩形的（即所有count[i]子数组的长度必须相同）。
      • 由counts表示的2维表必须至少有2列和至少2行。

      如果不满足任何前提条件，则会抛出IllegalArgumentException。

      参数:
      counts - 2维表的数组表示
      alpha - 测试的显著性水平
      返回:
      如果可以以置信度1 - alpha拒绝零假设，则为true
      抛出:
      NullArgumentException - 如果数组为null
      MathIllegalArgumentException - 如果数组不是矩形的
      MathIllegalArgumentException - 如果counts具有任何负条目
      MathIllegalArgumentException - 如果alpha不在范围（0, 0.5]内
      MathIllegalStateException - 如果计算p值时发生错误

    • chiSquareTest

      public static double chiSquareTest(long[][] counts) throws MathIllegalArgumentException, NullArgumentException, MathIllegalStateException
      返回与counts数组作为二维表视图的卡方独立性检验相关的观察到的显著性水平，或p值。

      2维表的行是count[0], ... , count[count.length - 1]

      前提条件:

      • 所有计数必须≥ 0。
      • 计数数组必须是矩形的（即所有count[i]子数组的长度必须相同）。
      • 由counts表示的2维表必须至少有2列和至少2行。

      如果不满足任何前提条件，则会抛出IllegalArgumentException。

      参数:
      counts - 2维表的数组表示
      返回:
      p值
      抛出:
      NullArgumentException - 如果数组为null
      MathIllegalArgumentException - 如果数组不是矩形的
      MathIllegalArgumentException - 如果counts具有负条目
      MathIllegalStateException - 如果计算p值时发生错误

    • chiSquareDataSetsComparison

      public static double chiSquareDataSetsComparison(long[] observed1, long[] observed2) throws MathIllegalArgumentException
      计算一个卡方双样本检验统计量，比较observed1和observed2中的频率计数。

      两个样本的频率计数之和不需要相同。用于计算检验统计量的公式为

      ∑[(K * observed1[i] - observed2[i]/K)2 / (observed1[i] + observed2[i])]

      其中

      K = √[∑(observed2 / ∑(observed1)]

      此统计量可用于执行卡方检验，评估观察计数是否遵循相同的分布的零假设。

      前提条件:

      • 观察计数必须是非负的。
      • 特定箱子的观察计数不能都为零。
      • 特定样本的观察计数不能全部为0。
      • 数组observed1和observed2必须具有相同的长度，它们的共同长度必须至少为2。

      如果不满足任何前提条件，则会抛出一个IllegalArgumentException。

      参数:
      observed1 - 第一个数据集的观察频率计数数组
      observed2 - 第二个数据集的观察频率计数数组
      返回:
      卡方检验统计量
      抛出:
      MathIllegalArgumentException - 数组的长度不匹配
      MathIllegalArgumentException - 如果observed1或observed2中的任何条目为负数
      MathIllegalArgumentException - 如果observed1或observed2的所有计数都为零，或者如果两个数组在相同索引处的计数都为零

    • chiSquareTestDataSetsComparison

      public static double chiSquareTestDataSetsComparison(long[] observed1, long[] observed2) throws MathIllegalArgumentException, MathIllegalStateException
      返回与比较observed1和observed2中的频率计数的卡方双样本检验相关联的观察显著水平，或p值。

      返回的数字是可以拒绝观察计数符合相同分布的零假设的最小显著水平。

      有关用于计算检验统计量的公式的详细信息，请参见chiSquareDataSetsComparison(long[], long[])。用于执行测试的自由度比输入观察计数数组的公共长度少一个。

      前提条件:

      • 观察计数必须是非负的。
      • 特定箱子的观察计数不能都为零。
      • 特定样本的观察计数不能全部为0。
      • 数组observed1和observed2必须具有相同的长度，它们的共同长度必须至少为2。

      如果不满足任何前提条件，则会抛出一个IllegalArgumentException。

      参数:
      observed1 - 第一个数据集的观察频率计数数组
      observed2 - 第二个数据集的观察频率计数数组
      返回:
      p值
      抛出:
      MathIllegalArgumentException - 数组的长度不匹配
      MathIllegalArgumentException - 如果observed1或observed2中的任何条目为负数
      MathIllegalArgumentException - 如果observed1或observed2的所有计数都为零，或者如果两个数组在相同索引处的计数都为零
      MathIllegalStateException - 如果计算p值时发生错误

    • chiSquareTestDataSetsComparison

      public static boolean chiSquareTestDataSetsComparison(long[] observed1, long[] observed2, double alpha) throws MathIllegalArgumentException, MathIllegalStateException
      执行卡方双样本检验，比较两个分组数据集。该检验评估了两个观察计数列表符合相同频率分布的零假设，显著水平为alpha。如果可以以100 * (1 - alpha)百分比的置信度拒绝零假设，则返回true。

      有关用于计算测试中使用的卡方统计量的公式的详细信息，请参见chiSquareDataSetsComparison(long[], long[])。用于执行测试的自由度比输入观察计数数组的公共长度少一个。

      前提条件:

      • 观察计数必须是非负的。
      • 特定箱子的观察计数不能都为零。
      • 特定样本的观察计数不能全部为0。
      • 数组observed1和observed2必须具有相同的长度，它们的共同长度必须至少为2。
      • 0 < alpha < 0.5

      如果不满足任何前提条件，则会抛出一个IllegalArgumentException。

      参数:
      observed1 - 第一个数据集的观察频率计数数组
      observed2 - 第二个数据集的观察频率计数数组
      alpha - 测试的显著水平
      返回:
      如果可以以置信度1 - alpha拒绝零假设，则为true
      抛出:
      MathIllegalArgumentException - 数组的长度不匹配
      MathIllegalArgumentException - 如果observed1或observed2中的任何条目为负数
      MathIllegalArgumentException - 如果observed1或observed2的所有计数都为零，或者如果两个数组在相同索引处的计数都为零
      MathIllegalArgumentException - 如果alpha不在范围(0, 0.5]内
      MathIllegalStateException - 执行测试时发生错误

    • oneWayAnovaFValue

      public static double oneWayAnovaFValue(Collection<double[]> categoryData) throws MathIllegalArgumentException, NullArgumentException
      计算一组double[]数组的ANOVA F值。

      前提条件:

      • categoryData Collection必须包含double[]数组。
      • categoryData集合中必须至少有两个double[]数组，每个数组必须包含至少两个值。

      此实现使用定义公式计算F统计量

         F = msbg/mswg

      其中

        msbg = 组间均方
  mswg = 组内均方

      如此处所定义 这里

      参数:
      categoryData - 包含每个类别数据的double[]数组的Collection
      返回:
      F值
      抛出:
      NullArgumentException - 如果categoryData为null
      MathIllegalArgumentException - 如果categoryData数组的长度小于2或包含的double[]数组没有至少两个值

    • oneWayAnovaPValue

      public static double oneWayAnovaPValue(Collection<double[]> categoryData) throws MathIllegalArgumentException, NullArgumentException, MathIllegalStateException
      计算一组double[]数组的ANOVA P值。

      前提条件:

      • categoryData Collection必须包含double[]数组。
      • categoryData集合中必须至少有两个double[]数组，每个数组必须包含至少两个值。

      此实现使用Hipparchus F分布实现来估计精确的p值，使用公式

         p = 1 - cumulativeProbability(F)

      其中F是F值，cumulativeProbability是F分布的Hipparchus实现。

      参数:
      categoryData - 包含每个类别数据的double[]数组的Collection
      返回:
      P值
      抛出:
      NullArgumentException - 如果categoryData为null
      MathIllegalArgumentException - 如果categoryData数组的长度小于2或包含的double[]数组没有至少两个值
      MathIllegalStateException - 如果由于收敛错误而无法计算p值
      MathIllegalStateException - 如果超过最大迭代次数

    • oneWayAnovaTest

      public static boolean oneWayAnovaTest(Collection<double[]> categoryData, double alpha) throws MathIllegalArgumentException, NullArgumentException, MathIllegalStateException
      Performs an ANOVA test, evaluating the null hypothesis that there is no difference among the means of the data categories.

      Preconditions:

      • The categoryData Collection must contain double[] arrays.
      • There must be at least two double[] arrays in the categoryData collection and each of these arrays must contain at least two values.
      • alpha must be strictly greater than 0 and less than or equal to 0.5.

      This implementation uses the Hipparchus F Distribution implementation to estimate the exact p-value, using the formula

         p = 1 - cumulativeProbability(F)

      where F is the F value and cumulativeProbability is the Hipparchus implementation of the F distribution.

      True is returned iff the estimated p-value is less than alpha.

      参数:
      categoryData - Collection of double[] arrays each containing data for one category
      alpha - significance level of the test
      返回:
      true if the null hypothesis can be rejected with confidence 1 - alpha
      抛出:
      NullArgumentException - if categoryData is null
      MathIllegalArgumentException - if the length of the categoryData array is less than 2 or a contained double[] array does not have at least two values
      MathIllegalArgumentException - if alpha is not in the range (0, 0.5]
      MathIllegalStateException - if the p-value can not be computed due to a convergence error
      MathIllegalStateException - if the maximum number of iterations is exceeded

    • g

      public static double g(double[] expected, long[] observed) throws MathIllegalArgumentException
      Computes the G statistic for Goodness of Fit comparing observed and expected frequency counts.

      This statistic can be used to perform a G test (Log-Likelihood Ratio Test) evaluating the null hypothesis that the observed counts follow the expected distribution.

      Preconditions:

      • Expected counts must all be positive.
      • Observed counts must all be ≥ 0.
      • The observed and expected arrays must have the same length and their common length must be at least 2.

      If any of the preconditions are not met, a MathIllegalArgumentException is thrown.

      Note:This implementation rescales the expected array if necessary to ensure that the sum of the expected and observed counts are equal.

      参数:
      expected - array of expected frequency counts
      observed - array of observed frequency counts
      返回:
      G-Test statistic
      抛出:
      MathIllegalArgumentException - if observed has negative entries
      MathIllegalArgumentException - if expected has entries that are not strictly positive
      MathIllegalArgumentException - if the array lengths do not match or are less than 2.

    • gTest

      public static double gTest(double[] expected, long[] observed) throws MathIllegalArgumentException, MathIllegalStateException
      Returns the observed significance level, or p-value, associated with a G-Test for goodness of fit comparing the observed frequency counts to those in the expected array.

      The number returned is the smallest significance level at which one can reject the null hypothesis that the observed counts conform to the frequency distribution described by the expected counts.

      The probability returned is the tail probability beyond g(expected, observed) in the ChiSquare distribution with degrees of freedom one less than the common length of expected and observed.

      Preconditions:

      • Expected counts must all be positive.
      • Observed counts must all be ≥ 0.
      • The observed and expected arrays must have the same length and their common length must be at least 2.

      If any of the preconditions are not met, a MathIllegalArgumentException is thrown.

      Note:This implementation rescales the expected array if necessary to ensure that the sum of the expected and observed counts are equal.

      参数:
      expected - array of expected frequency counts
      observed - array of observed frequency counts
      返回:
      p-value
      抛出:
      MathIllegalArgumentException - if observed has negative entries
      MathIllegalArgumentException - if expected has entries that are not strictly positive
      MathIllegalArgumentException - if the array lengths do not match or are less than 2.
      MathIllegalStateException - if an error occurs computing the p-value.

    • gTestIntrinsic

      public static double gTestIntrinsic(double[] expected, long[] observed) throws MathIllegalArgumentException, MathIllegalStateException
      Returns the intrinsic (Hardy-Weinberg proportions) p-Value, as described in p64-69 of McDonald, J.H. 2009. Handbook of Biological Statistics (2nd ed.). Sparky House Publishing, Baltimore, Maryland.

      The probability returned is the tail probability beyond g(expected, observed) in the ChiSquare distribution with degrees of freedom two less than the common length of expected and observed.

      参数:
      expected - array of expected frequency counts
      observed - array of observed frequency counts
      返回:
      p-value
      抛出:
      MathIllegalArgumentException - if observed has negative entries
      MathIllegalArgumentException - expected has entries that are not strictly positive
      MathIllegalArgumentException - if the array lengths do not match or are less than 2.
      MathIllegalStateException - if an error occurs computing the p-value.

    • gTest

      public static boolean gTest(double[] expected, long[] observed, double alpha) throws MathIllegalArgumentException, MathIllegalStateException
      Performs a G-Test (Log-Likelihood Ratio Test) for goodness of fit evaluating the null hypothesis that the observed counts conform to the frequency distribution described by the expected counts, with significance level alpha. Returns true iff the null hypothesis can be rejected with 100 * (1 - alpha) percent confidence.

      Example:
      To test the hypothesis that observed follows expected at the 99% level, use

      gTest(expected, observed, 0.01)

      Returns true iff gTestGoodnessOfFitPValue(expected, observed) > alpha

      Preconditions:

      • Expected counts must all be positive.
      • Observed counts must all be ≥ 0.
      • The observed and expected arrays must have the same length and their common length must be at least 2.
      • 0 < alpha < 0.5

      If any of the preconditions are not met, a MathIllegalArgumentException is thrown.

      Note:This implementation rescales the expected array if necessary to ensure that the sum of the expected and observed counts are equal.

      参数:
      expected - array of expected frequency counts
      observed - array of observed frequency counts
      alpha - significance level of the test
      返回:
      true iff null hypothesis can be rejected with confidence 1 - alpha
      抛出:
      MathIllegalArgumentException - if observed has negative entries
      MathIllegalArgumentException - if expected has entries that are not strictly positive
      MathIllegalArgumentException - if the array lengths do not match or are less than 2.
      MathIllegalStateException - if an error occurs computing the p-value.
      MathIllegalArgumentException - if alpha is not strictly greater than zero and less than or equal to 0.5

    • gDataSetsComparison

      public static double gDataSetsComparison(long[] observed1, long[] observed2) throws MathIllegalArgumentException

      计算独立性的G（对数似然比）双样本检验统计量，比较observed1和observed2中的频率计数。两个样本的频率计数之和不需要相同。用于计算检验统计量的公式为

      2 * totalSum * [H(rowSums) + H(colSums) - H(k)]

      其中H是将参数数组的元素视为发生计数形成的随机变量的香农熵；
      k是一个具有行[observed1, observed2]的矩阵；
      rowSums, colSums是k的行/列和；
      而totalSum是k中所有条目的总和。

      此统计量可用于执行G检验，评估观察计数是否独立

      前提条件：

      • 观察计数必须为非负数。
      • 特定箱的观察计数不能都为零。
      • 特定样本的观察计数不能都为0。
      • 数组observed1和observed2必须具有相同的长度，它们的公共长度必须至少为2。

      如果不满足任何前提条件，则会抛出MathIllegalArgumentException。

      参数:
      observed1 - 第一个数据集的观察频率计数数组
      observed2 - 第二个数据集的观察频率计数数组
      返回:
      G-检验统计量
      抛出:
      MathIllegalArgumentException - 数组的长度不匹配或它们的公共长度小于2
      MathIllegalArgumentException - 如果observed1或observed2中的任何条目为负数
      MathIllegalArgumentException - 如果observed1或observed2的所有计数都为零，或者如果相同索引处的计数对于两个数组都为零。

    • rootLogLikelihoodRatio

      public static double rootLogLikelihoodRatio(long k11, long k12, long k21, long k22) throws MathIllegalArgumentException
      计算两个状态数据集的根对数似然比。参见gDataSetsComparison(long[], long[])。

      给定两个事件A和B，设k11为两个事件同时发生的次数，k12为B发生而A不发生的次数，k21为A发生而B不发生的次数，k22为既不发生A也不发生B的次数。此方法返回的是

      (sgn) sqrt(gValueDataSetsComparison({k11, k12}, {k21, k22})

      其中sgn为-1，如果k11 / (k11 + k12) < k21 / (k21 + k22))；
      否则为1。

      有符号的根LLR相对于基本LLR有两个优点：a）当k11大于预期时为正，小于预期时为负 b）如果没有差异，它在渐近情况下服从正态分布。这使得可以谈论“标准偏差的数量”，这是比卡方分布更常见的参考框架。

      参数:
      k11 - 两个事件同时发生的次数（AB）
      k12 - 第二个事件发生而第一个事件未发生的次数（非A,B）
      k21 - 第一个事件发生而第二个事件未发生的次数（A,非B）
      k22 - 其他事件发生的次数（即既不是这两个事件的事件（非A,非B））
      返回:
      根对数似然比
      抛出:
      MathIllegalArgumentException

    • gTestDataSetsComparison

      public static double gTestDataSetsComparison(long[] observed1, long[] observed2) throws MathIllegalArgumentException, MathIllegalStateException

      返回与G值（对数似然比）相关的两个样本检验中比较observed1和observed2中的箱频率计数的观察显著水平或p值。

      返回的数字是可以拒绝观察计数符合相同分布的零假设的最小显著水平。

      有关如何计算p值的详细信息，请参见gTest(double[], long[])。用于执行测试的自由度比输入观察计数数组的公共长度少一个。

      前提条件：

      • 观察计数必须为非负数。
      • 特定箱的观察计数不能都为零。
      • 特定样本的观察计数不能都为0。
      • 数组observed1和observed2必须具有相同的长度，它们的公共长度必须至少为2。

      如果不满足任何前提条件，则会抛出MathIllegalArgumentException。

      参数:
      observed1 - 第一个数据集的观察频率计数数组
      observed2 - 第二个数据集的观察频率计数数组
      返回:
      p值
      抛出:
      MathIllegalArgumentException - 数组的长度不匹配或它们的公共长度小于2
      MathIllegalArgumentException - 如果observed1或observed2中的任何条目为负数
      MathIllegalArgumentException - 如果observed1或observed2的所有计数都为零，或者如果某个索引处的计数对于两个数组都为零
      MathIllegalStateException - 如果计算p值时发生错误。

    • gTestDataSetsComparison

      public static boolean gTestDataSetsComparison(long[] observed1, long[] observed2, double alpha) throws MathIllegalArgumentException, MathIllegalStateException

      执行G-检验（对数似然比检验），比较两个分组数据集。该检验评估了两个观察计数列表符合相同频率分布的零假设，显著水平为alpha。如果可以以100 *（1- alpha）百分比的置信度拒绝零假设，则返回true。

      有关用于计算测试中使用的G（LLR）统计量的公式的详细信息，请参见gDataSetsComparison(long[], long[])，有关如何计算观察显著水平的信息，请参见gTest(double[], long[])。用于执行测试的自由度比输入观察计数数组的公共长度少一个。

      前提条件：

      • 观察计数必须为非负数。
      • 特定箱的观察计数不能都为零。
      • 特定样本的观察计数不能都为0。
      • 数组observed1和observed2必须具有相同的长度，它们的公共长度必须至少为2。
      • 0 < alpha < 0.5

      如果不满足任何前提条件，则会抛出MathIllegalArgumentException。

      参数:
      observed1 - 第一个数据集的观察频率计数数组
      observed2 - 第二个数据集的观察频率计数数组
      alpha - 测试的显著水平
      返回:
      如果可以以置信度1 - alpha拒绝零假设，则为true
      抛出:
      MathIllegalArgumentException - 数组的长度不匹配
      MathIllegalArgumentException - 如果observed1或observed2中的任何条目为负数
      MathIllegalArgumentException - 如果observed1或observed2的所有计数都为零，或者如果某个索引处的计数对于两个数组都为零
      MathIllegalArgumentException - 如果alpha不在范围（0, 0.5]内
      MathIllegalStateException - 如果执行测试时发生错误

    • kolmogorovSmirnovStatistic

      public static double kolmogorovSmirnovStatistic(RealDistribution dist, double[] data) throws MathIllegalArgumentException, NullArgumentException
      计算一样本Kolmogorov-Smirnov检验统计量，\(D_n=\sup_x |F_n(x)-F(x)|\)，其中\(F\)是与distribution相关的分布（cdf）函数，\(n\)是data的长度，\(F_n\)是将质量\(1/n\)放在data中的每个值上的经验分布。
      参数:
      dist - 参考分布
      data - 正在评估的样本
      返回:
      Kolmogorov-Smirnov统计量\(D_n\)
      抛出:
      MathIllegalArgumentException - 如果data的长度不至少为2
      NullArgumentException - 如果data为null

    • kolmogorovSmirnovTest

      public static double kolmogorovSmirnovTest(RealDistribution dist, double[] data) throws MathIllegalArgumentException, NullArgumentException
      计算一样本Kolmogorov-Smirnov检验的p值，评估data是否符合distribution的零假设。
      参数:
      dist - 参考分布
      data - 正在评估的样本
      返回:
      与零假设相关的data是来自distribution的样本的p值
      抛出:
      MathIllegalArgumentException - 如果data的长度不至少为2
      NullArgumentException - 如果data为null

    • kolmogorovSmirnovTest

      public static double kolmogorovSmirnovTest(RealDistribution dist, double[] data, boolean strict) throws MathIllegalArgumentException, NullArgumentException
      计算一个样本的Kolmogorov-Smirnov检验的p值，或观察到的显著水平，评估data符合distribution的零假设。如果exact为true，则用扩展精度计算用于计算p值的分布。参见KolmogorovSmirnovTest.cdfExact(double, int)。
      参数:
      dist - 参考分布
      data - 正在评估的样本
      strict - 是否强制精确计算p值
      返回:
      与零假设相关的p值，即data是来自distribution的样本的概率
      抛出:
      MathIllegalArgumentException - 如果data的长度小于2
      NullArgumentException - 如果data为null

    • kolmogorovSmirnovTest

      public static boolean kolmogorovSmirnovTest(RealDistribution dist, double[] data, double alpha) throws MathIllegalArgumentException, NullArgumentException
      执行一个Kolmogorov-Smirnov检验，评估data符合distribution的零假设。
      参数:
      dist - 参考分布
      data - 正在评估的样本
      alpha - 检验的显著水平
      返回:
      如果且仅如果可以以置信度1 - alpha拒绝data是来自distribution的样本的零假设
      抛出:
      MathIllegalArgumentException - 如果data的长度小于2
      NullArgumentException - 如果data为null

    • kolmogorovSmirnovStatistic

      public static double kolmogorovSmirnovStatistic(double[] x, double[] y) throws MathIllegalArgumentException, NullArgumentException
      计算两样本Kolmogorov-Smirnov检验统计量，\(D_{n,m}=\sup_x |F_n(x)-F_m(x)|\)，其中\(n\)是x的长度，\(m\)是y的长度，\(F_n\)是将质量\(1/n\)放在x中的每个值上的经验分布，\(F_m\)是y值的经验分布。
      参数:
      x - 第一个样本
      y - 第二个样本
      返回:
      用于评估x和y代表来自相同基础分布的样本的检验统计量\(D_{n,m}\)
      抛出:
      MathIllegalArgumentException - 如果x或y的长度小于2
      NullArgumentException - 如果x或y为null

    • kolmogorovSmirnovTest

      public static double kolmogorovSmirnovTest(double[] x, double[] y) throws MathIllegalArgumentException, NullArgumentException
      计算一个两样本Kolmogorov-Smirnov检验的p值，或观察到的显著水平，评估x和y是否是从相同概率分布中抽取的样本的零假设。假定用于计算p值的不等式的严格形式。参见KolmogorovSmirnovTest.kolmogorovSmirnovTest(RealDistribution, double[], boolean)。
      参数:
      x - 第一个样本数据集
      y - 第二个样本数据集
      返回:
      与零假设相关的p值，即x和y代表来自相同分布的样本的概率
      抛出:
      MathIllegalArgumentException - 如果x或y的长度小于2
      NullArgumentException - 如果x或y为null

    • kolmogorovSmirnovTest

      public static double kolmogorovSmirnovTest(double[] x, double[] y, boolean strict) throws MathIllegalArgumentException, NullArgumentException
      计算一个两样本Kolmogorov-Smirnov检验的p值，或观察到的显著水平，评估x和y是否是从相同概率分布中抽取的样本的零假设。具体来说，返回的是一个估计概率，即从将组合样本随机分成大小为x.length和y.length的子样本的过程中，kolmogorovSmirnovStatistic(x, y)将严格超过（如果strict为true）或至少与strict = false一样大的概率。

      如果x.length * y.length < KolmogorovSmirnovTest.LARGE_SAMPLE_PRODUCT，并且x和y中包含相同值，则在计算\(D_{n,m}\)和p值之前，向x和y添加随机抖动以打破平局。抖动在(-minDelta / 2, minDelta / 2)上均匀分布，其中minDelta是组合样本中值之间的最小两两差异。

      如果数据中已知存在平局，则可以使用KolmogorovSmirnovTest.bootstrap(double[], double[], int, boolean)作为估计p值的替代方法。

      参数:
      x - 第一个样本数据集
      y - 第二个样本数据集
      strict - 是否将要计算的概率表示为严格不等式（对于大样本不起作用）
      返回:
      与零假设相关的p值，即x和y代表来自相同分布的样本的概率
      抛出:
      MathIllegalArgumentException - 如果x或y的长度小于2
      NullArgumentException - 如果x或y为null
      另请参阅:

    • exactP

      public static double exactP(double d, int m, int n, boolean strict)
      如果strict为true，则计算\(P(D_{n,m} > d)\)；否则计算\(P(D_{n,m} \ge d)\)，其中\(D_{n,m}\)是2样本Kolmogorov-Smirnov统计量。有关\(D_{n,m}\)的定义，请参见KolmogorovSmirnovTest.kolmogorovSmirnovStatistic(double[], double[])。

      返回的概率是精确的，通过展开[4]中类文档中给出的递归函数定义来实现。

      参数:
      d - D统计值
      m - 第二个样本大小
      n - 第一个样本大小
      strict - 是否将要计算的概率表示为严格不等式
      返回:
      随机选择的m-n分区生成\(D_{n,m}\)大于（或大于等于）d的概率

    • approximateP

      public static double approximateP(double d, int n, int m)
      使用Kolmogorov-Smirnov分布来近似\(P(D_{n,m} > d)\)，其中\(D_{n,m}\)是2样本Kolmogorov-Smirnov统计量。有关\(D_{n,m}\)的定义，请参见KolmogorovSmirnovTest.kolmogorovSmirnovStatistic(double[], double[])。

      具体来说，返回的是\(1 - k(d \sqrt{mn / (m + n)})\)，其中\(k(t) = 1 + 2 \sum_{i=1}^\infty (-1)^i e^{-2 i^2 t^2}\)。有关如何确定和的收敛性的详细信息，请参见KolmogorovSmirnovTest.ksSum(double, double, int)。此实现将ksSum作为tolerance传递KolmogorovSmirnovTest.KS_SUM_CAUCHY_CRITERION，将KolmogorovSmirnovTest.MAXIMUM_PARTIAL_SUM_COUNT作为maxIterations传递。

      参数:
      d - D统计值
      n - 第一个样本大小
      m - 第二个样本大小
      返回:
      大于d的随机选择的m-n分区生成\(D_{n,m}\)的近似概率