MultipleTesting.jl

https://juliangehring.github.io/MultipleTesting.jl/dev/
Admin
MultipleTesting.jl is a Julia package offering algorithms for p-value adjustment, combination, and...
Tokens:8,786
Snippets:87
Trust Score:9.7
Update:5 months ago
Show doc for...
Tokens:
Raw
### Hommel Adjustment

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/adjustment

Implements the Hommel adjustment, a stagewise rejective multiple test procedure. Examples show usage with and without specifying the total number of tests.

```julia
julia> pvals = PValues([0.001, 0.01, 0.03, 0.5]);

julia> adjust(pvals, Hommel())
4-element Array{Float64,1}:
 0.004
 0.03
 0.06
 0.5

julia> adjust(pvals, 6, Hommel())
4-element Array{Float64,1}:
 0.006
 0.05
 0.12
 1.0
```

--------------------------------

### Šidák Adjustment

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/adjustment

Applies the Šidák correction to p-values. Examples demonstrate its use with and without specifying the total number of tests.

```julia
julia> pvals = PValues([0.001, 0.01, 0.03, 0.5]);

julia> adjust(pvals, Sidak())
4-element Array{Float64,1}:
 0.003994003998999962
 0.039403990000000055
 0.11470719000000007
 0.9375

julia> adjust(pvals, 6, Sidak())
4-element Array{Float64,1}:
 0.0059850199850060015
 0.058519850599
 0.1670279950710002
 0.984375
```

--------------------------------

### Estimate π₀ using StoreyBootstrap

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/pi0

Estimates π₀ using the StoreyBootstrap method. Requires a PValues object.

```julia
pvals = PValues([0.001, 0.002, 0.01, 0.03, 0.5]);

estimate(pvals, StoreyBootstrap())
```

--------------------------------

### Estimate π₀ using Right Boundary, BUM, and Flat Grenander methods

Source: https://juliangehring.github.io/MultipleTesting.jl/dev

Estimate π₀ using methods like Right Boundary (Storey's estimate with dynamic λ), Beta-Uniform Mixture (BUM), Censored BUM, and Flat Grenander.

```julia
estimate(pvals, RightBoundary())
```

```julia
estimate(pvals, CensoredBUM())
```

```julia
estimate(pvals, BUM())
```

```julia
estimate(pvals, FlatGrenander())
```

--------------------------------

### Create Beta Uniform Mixture Model

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/models

Instantiate a Beta Uniform Mixture Model with a specified fraction of the uniform distribution and parameters for the Beta distribution. Requires the Distributions package for usage.

```julia
bum = BetaUniformMixtureModel(0.2, 0.5, 1.0);
```

```julia
using Distributions
```

```julia
pdf.(bum, 0.2:0.2:1.0)
```

--------------------------------

### Combine p-values using Tippett's method

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/combination

Combine p-values using Tippett's method. Ensure PValues are properly initialized.

```julia
pvals = PValues([0.01, 0.02, 0.3, 0.5])

combine(pvals, Tippett())
```

--------------------------------

### Combine p-values using Logit, Tippett, and Simes methods

Source: https://juliangehring.github.io/MultipleTesting.jl/dev

Combine p-values using the Logit, Tippett, or Simes methods.

```julia
combine(pvals, Logit())
```

```julia
combine(pvals, Tippett())
```

```julia
combine(pvals, Simes())
```

--------------------------------

### Combine p-values using Minimum with ForwardStop

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/combination

Combine p-values using the Minimum method with ForwardStop adjustment.

```julia
combine(pv, Minimum(ForwardStop()))
```

--------------------------------

### Estimate π₀ using Least Slope and Two Step methods

Source: https://juliangehring.github.io/MultipleTesting.jl/dev

Estimate π₀ using the Least Slope method or the Two Step method. The Two Step method can optionally take a significance level and a method for adaptive Benjamini-Hochberg.

```julia
estimate(pvals, LeastSlope())
```

```julia
estimate(pvals, TwoStep())
```

```julia
estimate(pvals, TwoStep(0.05))
```

```julia
estimate(pvals, TwoStep(0.05, BenjaminiHochbergAdaptive(0.9)))
```

--------------------------------

### Estimate π₀ using Oracle method

Source: https://juliangehring.github.io/MultipleTesting.jl/dev

Estimate π₀ using the Oracle method when the true proportion is known.

```julia
estimate(pvals, Oracle(0.9))
```

--------------------------------

### Estimate π₀ using FlatGrenander

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/pi0

Estimates π₀ using the FlatGrenander method. Requires a PValues object.

```julia
pvals = PValues([0.001, 0.002, 0.01, 0.03, 0.5]);

estimate(pvals, FlatGrenander())
```

--------------------------------

### Combine p-values using Logit method

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/combination

Combine p-values using the Logit method. Requires PValues to be initialized.

```julia
pvals = PValues([0.01, 0.02, 0.3, 0.5])

combine(pvals, Logit())
```

--------------------------------

### Combine p-values using Simes's method

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/combination

Combine p-values using Simes's method. Requires PValues to be initialized.

```julia
pvals = PValues([0.01, 0.02, 0.3, 0.5])

combine(pvals, Simes())
```

--------------------------------

### Beta-Uniform Mixture (BUM) π₀ Estimator

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/pi0

Estimates π₀ using the BUM method. This is a mixture model approach for π₀ estimation.

```julia
julia> pvals = PValues([0.001, 0.002, 0.01, 0.03, 0.5]);

julia> estimate(pvals, BUM())
0.22802795505154264
```

--------------------------------

### MultipleTesting.Tippett

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/combination

Implements Tippett's method for combining p-values.

```APIDOC
## Tippett

### Description
Tippett's p-value combination method.

### Method Signature
`combine(pvals, Tippett())`

### Parameters
- **pvals**: A collection of p-values.
- **Tippett()**: The Tippett combination method.

### Examples
```julia
pvals = PValues([0.01, 0.02, 0.3, 0.5])

combine(pvals, Tippett())
# Output: 0.039403990000000055
```

### References
Tippett, L.H.C. (1931). The Methods of Statistics. An introduction mainly for workers in the biological sciences.
```

--------------------------------

### Right Boundary π₀ Estimator

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/pi0

Estimates π₀ using the right boundary method. Can be configured with specific lambda ranges.

```julia
julia> pvals = PValues([0.001, 0.002, 0.01, 0.03, 0.5]);

julia> estimate(pvals, RightBoundary())
0.2127659574468085
```

```julia
julia> estimate(pvals, RightBoundary(0.1:0.1:0.9))
0.25
```

--------------------------------

### Combine p-values using Minimum with BenjaminiHochberg

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/combination

Combine p-values using the Minimum method with BenjaminiHochberg adjustment.

```julia
pv = PValues([0.01, 0.02, 0.3, 0.5])

combine(pv, Minimum(BenjaminiHochberg()))
```

--------------------------------

### MultipleTesting.Logit

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/combination

Implements the Logit method for combining p-values.

```APIDOC
## Logit

### Description
Logit p-value combination method.

### Method Signature
`combine(pvals, Logit())`

### Parameters
- **pvals**: A collection of p-values.
- **Logit()**: The Logit combination method.

### Examples
```julia
pvals = PValues([0.01, 0.02, 0.3, 0.5])

combine(pvals, Logit())
# Output: 0.006434494635148462
```

### References
Mudholkar, G.S., and George, E.O. (1977). The Logit Statistic for Combining Probabilities - An Overview (Rochester University NY, Dept of Statistics).
```

--------------------------------

### Combine p-values using Stouffer's method

Source: https://juliangehring.github.io/MultipleTesting.jl/dev

Combine p-values using Stouffer's method, optionally with provided weights.

```julia
combine(pvals, Stouffer())
```

```julia
combine(pvals, weights, Stouffer())
```

--------------------------------

### Two-Step π₀ Estimator

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/pi0

Estimates π₀ using a two-step procedure. Can be configured with specific thresholds and procedures.

```julia
julia> pvals = PValues([0.001, 0.002, 0.01, 0.03, 0.5]);

julia> estimate(pvals, TwoStep())
0.2
```

```julia
julia> estimate(pvals, TwoStep(0.05, BenjaminiLiu()))
0.2
```

--------------------------------

### BetaUniformMixtureModel

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/models

Constructs a Beta Uniform Mixture (BUM) Model. This model is composed of a uniform distribution and a Beta distribution, weighted by a specified fraction.

```APIDOC
## Function `MultipleTesting.BetaUniformMixtureModel`

### Description
Constructs a Beta Uniform Mixture (BUM) Model, which is a mixture of a uniform distribution and a Beta distribution.

### Parameters
* `π0` (Float64): The weight/prior for the uniform distribution component.
* `α` (Float64): The first parameter of the Beta distribution.
* `β` (Float64): The second parameter of the Beta distribution.

### Return values
* `MixtureModel`: A `MixtureModel` object from the `Distributions` package, representing the BUM model.

### Examples
```julia
bum = BetaUniformMixtureModel(0.2, 0.5, 1.0)
using Distributions
pdf.(bum, 0.2:0.2:1.0)
```
```

--------------------------------

### Adjust p-values using various methods

Source: https://juliangehring.github.io/MultipleTesting.jl/dev

Use the `adjust` function with different p-value adjustment methods like Bonferroni, Benjamini-Hochberg, and others. Some methods, like Benjamini-Hochberg Adaptive, can take an estimated π₀ value.

```julia
adjust(pvals, Bonferroni())
```

```julia
adjust(pvals, BenjaminiHochberg())
```

```julia
adjust(pvals, BenjaminiHochbergAdaptive(0.9))
```

```julia
adjust(pvals, BenjaminiHochbergAdaptive(Storey()))
```

```julia
adjust(pvals, BenjaminiYekutieli())
```

```julia
adjust(pvals, BenjaminiLiu())
```

```julia
adjust(pvals, Hochberg())
```

```julia
adjust(pvals, Holm())
```

```julia
adjust(pvals, Hommel())
```

```julia
adjust(pvals, Sidak())
```

```julia
adjust(pvals, ForwardStop())
```

```julia
adjust(pvals, BarberCandes())
```

--------------------------------

### MultipleTesting.Simes

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/combination

Implements Simes's method for combining p-values.

```APIDOC
## Simes

### Description
Simes's p-value combination method.

### Method Signature
`combine(pvals, Simes())`

### Parameters
- **pvals**: A collection of p-values.
- **Simes()**: The Simes combination method.

### Examples
```julia
pvals = PValues([0.01, 0.02, 0.3, 0.5])

combine(pvals, Simes())
# Output: 0.04
```

### References
Simes, R.J. (1986). An improved Bonferroni procedure for multiple tests of significance. Biometrika 73, 751–754.
```

--------------------------------

### Least Slope (LSL) π₀ Estimator

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/pi0

Estimates π₀ using the Least Slope method. This is a common method for π₀ estimation.

```julia
julia> pvals = PValues([0.001, 0.002, 0.01, 0.03, 0.5]);

julia> estimate(pvals, LeastSlope())
1.0
```

--------------------------------

### Adaptive Benjamini-Hochberg Adjustment

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/adjustment

Implements the adaptive Benjamini-Hochberg procedure, which can use a known proportion of true null hypotheses (π₀) or estimate it using Storey's bootstrap method.

```julia
julia> pvals = PValues([0.001, 0.01, 0.03, 0.5]);

julia> adjust(pvals, BenjaminiHochbergAdaptive(Oracle(0.5))) # known π₀ of 0.5
4-element Array{Float64,1}:
 0.002
 0.01
 0.019999999999999997
 0.25

julia> adjust(pvals, BenjaminiHochbergAdaptive(StoreyBootstrap())) # π₀ estimator
4-element Array{Float64,1}:
 0.0
 0.0
 0.0
 0.0

julia> adjust(pvals, 6, BenjaminiHochbergAdaptive(StoreyBootstrap()))
4-element Array{Float64,1}:
 0.0
 0.0
 0.0
 0.0
```

--------------------------------

### Adjust p-values using Benjamini-Hochberg

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/adjustment

Applies the Benjamini-Hochberg method to adjust a list of p-values. Ensure `PValues` is correctly initialized.

```julia
pvals = PValues([0.001, 0.01, 0.03, 0.5])
```

```julia
adjust(pvals, BenjaminiHochberg())
```

--------------------------------

### MultipleTesting.Minimum

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/combination

Implements the Minimum adjusted p-value combination method.

```APIDOC
## Minimum

### Description
Minimum of adjusted p-value combination method.

### Method Signature
`combine(pv, Minimum(adjustment_method()))`

### Parameters
- **pv**: A collection of p-values.
- **Minimum(adjustment_method())**: The Minimum combination method with a specified adjustment method (e.g., BenjaminiHochberg, ForwardStop).

### Examples
```julia
pv = PValues([0.01, 0.02, 0.3, 0.5])

combine(pv, Minimum(BenjaminiHochberg()))
# Output: 0.04

combine(pv, Minimum(ForwardStop()))
# Output: 0.01005033585350145
```
```

--------------------------------

### MultipleTesting.combine

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/combination

Combines p-values using a specified combination method.

```APIDOC
## combine

### Description
Combines p-values using a specified combination method.

### Method Signature
`combine(PValues, <:PValueCombination)`

### Parameters
- **PValues**: A collection of p-values.
- **PValueCombination**: The type of p-value combination method to use (e.g., Fisher, Stouffer).

### Examples
```julia
pvals = PValues([0.01, 0.02, 0.3, 0.5])

combine(pvals, Fisher())
# Output: 0.007616871850449092

combine(pvals, Stouffer())
# Output: 0.00709832618126593
```
```

--------------------------------

### Combine p-values using Fisher's method

Source: https://juliangehring.github.io/MultipleTesting.jl/dev

Combine p-values using Fisher's method.

```julia
combine(pvals, Fisher())
```

--------------------------------

### Estimate π₀ using Storey's method

Source: https://juliangehring.github.io/MultipleTesting.jl/dev

Estimate the proportion of true null hypotheses (π₀) using Storey's method. This can be done directly or using a closed-form bootstrap.

```julia
estimate(pvals, Storey())
```

```julia
estimate(pvals, StoreyBootstrap())
```

--------------------------------

### Estimate Higher Criticism scores and threshold

Source: https://juliangehring.github.io/MultipleTesting.jl/dev

Estimate Higher Criticism scores and the Higher Criticism threshold using the `estimate` function.

```julia
estimate(pvals, HigherCriticismScores())
```

```julia
estimate(pvals, HigherCriticismThreshold())
```

--------------------------------

### Storey's Bootstrap π₀ Estimator

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/pi0

Estimates π₀ using a closed-form bootstrap method. Requires specifying lambda ranges and a lambda value.

```julia
julia> pvals = PValues([0.001, 0.002, 0.01, 0.03, 0.5]);

julia> estimate(pvals, StoreyBootstrap())
0.0
```

```julia
julia> estimate(pvals, StoreyBootstrap(0.1:0.1:0.9, 0.2))
0.0
```

--------------------------------

### Combine p-values using Wilkinson's method or minimum of adjusted p-values

Source: https://juliangehring.github.io/MultipleTesting.jl/dev

Combine p-values using Wilkinson's method, which requires a rank, or by taking the minimum of adjusted p-values using a specified PValueAdjustment method.

```julia
combine(pvals, Wilkinson(rank))
```

```julia
combine(pvals, Minimum(PValueAdjustment()))
```

--------------------------------

### ForwardStop Adjustment

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/adjustment

Applies the ForwardStop adjustment method to p-values. This method is useful for sequential selection procedures and controlling the false discovery rate.

```julia
julia> adjust(pvals, ForwardStop())
4-element Array{Float64,1}:
 0.0010005003335835344
 0.005525418093542492
 0.013836681223931188
 0.1836643060579347
```

```julia
julia> adjust(pvals, 6, ForwardStop())
4-element Array{Float64,1}:
 0.0010005003335835344
 0.005525418093542492
 0.013836681223931188
 0.1836643060579347
```

--------------------------------

### Combine p-values using Wilkinson's method

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/combination

Combine p-values using Wilkinson's method, specifying the rank for combination.

```julia
pv = PValues([0.01, 0.02, 0.3, 0.5])

combine(pv, Wilkinson(1))  # combination with rank 1
```

```julia
combine(pv, Wilkinson(4))  # combination with rank 4
```

--------------------------------

### ForwardStop Adjustment

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/adjustment

Applies the ForwardStop method for p-value adjustment. It can be used with or without a specified threshold.

```APIDOC
## `adjust(pvals, ForwardStop())`

### Description
Applies the ForwardStop adjustment method to a vector of p-values.

### Method
`adjust`

### Parameters
#### Path Parameters
- **pvals** (Array{Float64,1}) - Required - The input array of p-values.
- **ForwardStop()** - Required - The ForwardStop adjustment strategy.

### Response
#### Success Response (Array{Float64,1})
- Returns an array of adjusted p-values.

## `adjust(pvals, threshold, ForwardStop())`

### Description
Applies the ForwardStop adjustment method with a specified threshold.

### Method
`adjust`

### Parameters
#### Path Parameters
- **pvals** (Array{Float64,1}) - Required - The input array of p-values.
- **threshold** (Integer) - Required - The threshold value for the adjustment.
- **ForwardStop()** - Required - The ForwardStop adjustment strategy.

### Response
#### Success Response (Array{Float64,1})
- Returns an array of adjusted p-values.
```

--------------------------------

### Censored Beta-Uniform Mixture (censored BUM) π₀ Estimator

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/pi0

Estimates π₀ using the censored BUM method. This method is suitable for censored p-value data.

```julia
julia> pvals = PValues([0.001, 0.002, 0.01, 0.03, 0.5]);

julia> estimate(pvals, CensoredBUM())
0.21052495526400936
```

--------------------------------

### MultipleTesting.Stouffer

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/combination

Implements Stouffer's method for combining p-values, with optional weights.

```APIDOC
## Stouffer

### Description
Stouffer's p-value combination method.

### Method Signature
`combine(pvals, weights, Stouffer())` or `combine(pvals, Stouffer())`

### Parameters
- **pvals**: A collection of p-values.
- **weights**: Optional array of weights for each p-value.
- **Stouffer()**: The Stouffer combination method.

### Examples
```julia
pvals = PValues([0.01, 0.02, 0.3, 0.5])

combine(pvals, Stouffer())
# Output: 0.00709832618126593

weights = [1.0, 2.0, 0.4, 1.5]
combine(pvals, weights, Stouffer())
# Output: 0.007331653763696742
```

### References
Stouffer, S.A. (1949). The American soldier. Vol. 1: Adjustment during army life (Princeton University Press).
Liptak, T. (1958). On the combination of independent tests. Magyar Tud Akad Mat Kutato Int Kozl 3, 171–197.
```

--------------------------------

### Distributions.estimate

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/pi0

Estimates π₀, the fraction of tests under the null hypothesis, using provided p-values and a specified estimator.

```APIDOC
## Distributions.estimate

### Description
Estimates π₀, the fraction of tests under the null hypothesis.

### Signature
`estimate(PValues, <:Pi0Estimator)`

### Parameters
- **PValues**: A collection of p-values.
- **Pi0Estimator**: An object representing the chosen π₀ estimation method (e.g., `StoreyBootstrap()`, `FlatGrenander()`).

### Examples
```julia
pvals = PValues([0.001, 0.002, 0.01, 0.03, 0.5])

# Using StoreyBootstrap estimator
estimate(pvals, StoreyBootstrap())
# Output: 0.0

# Using FlatGrenander estimator
estimate(pvals, FlatGrenander())
# Output: 0.42553191489361697
```

### See Also
`Pi0Estimator`, `Storey`, `StoreyBootstrap`, `LeastSlope`, `Oracle`, `TwoStep`, `RightBoundary`, `CensoredBUM`, `BUM`, `FlatGrenander`, `ConvexDecreasing`
```

--------------------------------

### MultipleTesting.Wilkinson

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/combination

Implements Wilkinson's method for combining p-values based on rank.

```APIDOC
## Wilkinson

### Description
Wilkinson's p-value combination method.

### Method Signature
`combine(pv, Wilkinson(rank))`

### Parameters
- **pv**: A collection of p-values.
- **Wilkinson(rank)**: The Wilkinson combination method with a specified rank.

### Examples
```julia
pv = PValues([0.01, 0.02, 0.3, 0.5])

combine(pv, Wilkinson(1))  # combination with rank 1
# Output: 0.03940399000000003

combine(pv, Wilkinson(4))  # combination with rank 4
# Output: 0.0625
```

### References
Wilkinson, B. (1951). A statistical consideration in psychological research. Psychological Bulletin 48, 156.
```

--------------------------------

### Adjust p-values with a specified number of tests (Benjamini-Hochberg)

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/adjustment

Adjusts p-values using the Benjamini-Hochberg method, considering a specific total number of tests performed. This is useful when the number of tests is known and differs from the number of p-values provided.

```julia
adjust(pvals, 6, BenjaminiHochberg()) # 4 out of 6 p-values
```

--------------------------------

### Adjust k smallest p-values

Source: https://juliangehring.github.io/MultipleTesting.jl/dev

This function allows for the adjustment of a specific number 'k' of the smallest p-values out of a total of 'n' p-values, using a specified PValueAdjustmentMethod.

```julia
adjust(pvals, n, PValueAdjustmentMethod)
```

--------------------------------

### Storey's π₀ Estimator

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/pi0

Estimates π₀ using Storey's method. Can accept a lambda parameter.

```julia
julia> pvals = PValues([0.001, 0.002, 0.01, 0.03, 0.5]);

julia> estimate(pvals, Storey())
0.22222222222222224
```

```julia
julia> estimate(pvals, Storey(0.4))
0.33333333333333337
```

--------------------------------

### Oracle π₀ Estimator

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/pi0

The Oracle estimator provides the true π₀ value, often used for comparison. It requires the true π₀ value as input.

```julia
julia> pvals = PValues([0.001, 0.002, 0.01, 0.03, 0.5]);

julia> estimate(pvals, Oracle(0.5)) # a bit boring...
0.5
```

--------------------------------

### Benjamini-Liu Adjustment

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/adjustment

Applies the Benjamini-Liu step-down procedure for controlling the FDR. This method can also be applied with a specified number of tests.

```julia
julia> pvals = PValues([0.001, 0.01, 0.03, 0.5]);

julia> adjust(pvals, BenjaminiLiu())
4-element Array{Float64,1}:
 0.003994003998999962
 0.022275750000000066
 0.02955000000000002
 0.125

julia> adjust(pvals, 6, BenjaminiLiu())
4-element Array{Float64,1}:
 0.0059850199850060015
 0.04084162508333341
 0.07647146000000005
 0.4375
```

--------------------------------

### Estimate Higher Criticism Threshold

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/higher-criticism

Use `estimate` with `HigherCriticismThreshold` to determine a threshold for p-values. This method is effective for feature selection when useful features are rare and weak.

```julia
pvals = PValues([0.001, 0.01, 0.03, 0.5]);

estimate(pvals, HigherCriticismThreshold())

```

--------------------------------

### Benjamini-Yekutieli Adjustment

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/adjustment

Applies the Benjamini-Yekutieli adjustment, which controls the FDR under arbitrary dependency structures among the tests. It can also be used with a specified number of tests.

```julia
julia> pvals = PValues([0.001, 0.01, 0.03, 0.5]);

julia> adjust(pvals, BenjaminiYekutieli())
4-element Array{Float64,1}:
 0.00833333333333334
 0.0416666666666667
 0.0833333333333334
 1.0

julia> adjust(pvals, 6, BenjaminiYekutieli())
4-element Array{Float64,1}:
 0.01470000000000001
 0.07350000000000005
 0.14700000000000008
 1.0
```

--------------------------------

### Hochberg Adjustment

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/adjustment

Implements the Hochberg step-up procedure for multiple testing. The adjustment can be applied with or without specifying the total number of tests.

```julia
julia> pvals = PValues([0.001, 0.01, 0.03, 0.5]);

julia> adjust(pvals, Hochberg())
4-element Array{Float64,1}:
 0.004
 0.03
 0.06
 0.5

julia> adjust(pvals, 6, Hochberg())
4-element Array{Float64,1}:
 0.006
 0.05
 0.12
 1.0
```

--------------------------------

### MultipleTesting.Fisher

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/combination

Implements Fisher's method for combining p-values.

```APIDOC
## Fisher

### Description
Fisher's p-value combination method.

### Method Signature
`combine(pvals, Fisher())`

### Parameters
- **pvals**: A collection of p-values.
- **Fisher()**: The Fisher combination method.

### Examples
```julia
pvals = PValues([0.01, 0.02, 0.3, 0.5])

combine(pvals, Fisher())
# Output: 0.007616871850449092
```

### References
Fisher, R.A. (1925). Statistical methods for research workers (Genesis Publishing Pvt Ltd).
```

--------------------------------

### Holm Adjustment

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/adjustment

Applies the Holm-Bonferroni method, a sequentially rejective procedure. It can be used with or without providing the total number of tests.

```julia
julia> pvals = PValues([0.001, 0.01, 0.03, 0.5]);

julia> adjust(pvals, Holm())
4-element Array{Float64,1}:
 0.004
 0.03
 0.06
 0.5

julia> adjust(pvals, 6, Holm())
4-element Array{Float64,1}:
 0.006
 0.05
 0.12
 1.0
```

--------------------------------

### HigherCriticismThreshold

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/higher-criticism

Estimates the higher criticism threshold from a given set of p-values. This threshold can be used for signal identification.

```APIDOC
## `MultipleTesting.HigherCriticismThreshold` — Type

Higher criticism threshold

### Description
Estimates the higher criticism threshold from a given set of p-values.

### Usage
```julia
pvals = PValues([0.001, 0.01, 0.03, 0.5])
estimate(pvals, HigherCriticismThreshold())
```

### Response Example
```
0.03
```
```

--------------------------------

### Adjust p-values using Barber-Candes method

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/adjustment

Applies the Barber-Candes method for p-value adjustment. This method is an alternative to Benjamini-Hochberg and requires no specific number of tests to be provided.

```julia
adjust(pvals, BarberCandes())
```

--------------------------------

### Estimate Higher Criticism Scores

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/higher-criticism

Use `estimate` with `HigherCriticismScores` to calculate scores for each p-value. This is useful for identifying potentially significant features when useful features are rare and weak.

```julia
pvals = PValues([0.001, 0.01, 0.03, 0.5]);

estimate(pvals, HigherCriticismScores())

```

--------------------------------

### Bonferroni Adjustment

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/adjustment

Applies the Bonferroni correction to a set of p-values. Can optionally take the number of tests as an argument.

```julia
julia> pvals = PValues([0.001, 0.01, 0.03, 0.5]);

julia> adjust(pvals, Bonferroni())
4-element Array{Float64,1}:
 0.004
 0.04
 0.12
 1.0

julia> adjust(pvals, 6, Bonferroni())
4-element Array{Float64,1}:
 0.006
 0.06
 0.18
 1.0
```

--------------------------------

### Flat Grenander π₀ Estimator

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/pi0

Estimates π₀ by finding the longest constant interval in the Grenander estimator. Useful for identifying plateaus in the distribution.

```julia
julia> pvals = PValues([0.001, 0.002, 0.01, 0.03, 0.5]);

julia> estimate(pvals, FlatGrenander())
0.42553191489361697
```

--------------------------------

### Convex Decreasing π₀ Estimator

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/pi0

Estimates π₀ using a convex decreasing function. This method is often applied to microarray data.

```julia
julia> pvals = PValues([0.001, 0.002, 0.01, 0.03, 0.5]);

julia> estimate(pvals, ConvexDecreasing())
0.013007051336745304
```

--------------------------------

### MultipleTesting.adjust

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/adjustment

Adjusts p-values using a specified p-value adjustment method. It can optionally take the total number of hypotheses tested.

```APIDOC
## Function: MultipleTesting.adjust

### Description
Adjusts p-values using a specified p-value adjustment method. It can optionally take the total number of hypotheses tested.

### Signatures
- `adjust(PValues, <:PValueAdjustment)`
- `adjust(PValues, Int, <:PValueAdjustment)`

### Parameters
- `PValues`: A collection of p-values to be adjusted.
- `Int`: Optional. The total number of hypotheses tested.
- `PValueAdjustment`: The p-value adjustment method to use (e.g., `BenjaminiHochberg()`, `BarberCandes()`).

### Examples
```julia
pvals = PValues([0.001, 0.01, 0.03, 0.5])

# Using BenjaminiHochberg adjustment
adjust(pvals, BenjaminiHochberg())

# Using BenjaminiHochberg with total hypotheses = 6
adjust(pvals, 6, BenjaminiHochberg())

# Using BarberCandes adjustment
adjust(pvals, BarberCandes())
```

### See Also
`PValueAdjustment`, `Bonferroni`, `BenjaminiHochberg`, `BenjaminiHochbergAdaptive`, `BenjaminiYekutieli`, `BenjaminiLiu`, `Hochberg`, `Holm`, `Hommel`, `Sidak`, `ForwardStop`, `BarberCandes`
```

--------------------------------

### BarberCandes Adjustment

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/adjustment

Applies the Barber-Candes adjustment method for p-value adjustment.

```APIDOC
## `adjust(pvals, BarberCandes())`

### Description
Applies the Barber-Candes adjustment method to a vector of p-values.

### Method
`adjust`

### Parameters
#### Path Parameters
- **pvals** (PValues) - Required - The input p-values object.
- **BarberCandes()** - Required - The BarberCandes adjustment strategy.

### Response
#### Success Response (Array{Float64,1})
- Returns an array of adjusted p-values.
```

--------------------------------

### HigherCriticismScores

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/higher-criticism

Estimates higher criticism scores from a given set of p-values. This is useful for feature selection when useful features are rare and weak.

```APIDOC
## `MultipleTesting.HigherCriticismScores` — Type

Higher criticism scores

### Description
Estimates higher criticism scores from a given set of p-values.

### Usage
```julia
pvals = PValues([0.001, 0.01, 0.03, 0.5])
estimate(pvals, HigherCriticismScores())
```

### Response Example
```
4-element Array{Float64,1}:
 1.1500817362257345
 1.96
 3.3255375505322444
 2.3094010767584976
```
```

--------------------------------

### BarberCandes Adjustment

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/adjustment

Performs the Barber-Candes adjustment for controlling the false discovery rate. This method is distribution-free and suitable for various testing scenarios.

```julia
julia> pvals = PValues([0.001, 0.01, 0.03, 0.5]);

julia> adjust(pvals, BarberCandes())
4-element Array{Float64,1}:
 0.3333333333333333
 0.3333333333333333
 0.3333333333333333
 1.0
```

--------------------------------

### Benjamini-Hochberg Adjustment

Source: https://juliangehring.github.io/MultipleTesting.jl/dev/adjustment

Applies the Benjamini-Hochberg (BH) adjustment for controlling the False Discovery Rate (FDR). It can also be used with a specified number of tests.

```julia
julia> pvals = PValues([0.001, 0.01, 0.03, 0.5]);

julia> adjust(pvals, BenjaminiHochberg())
4-element Array{Float64,1}:
 0.004
 0.02
 0.039999999999999994
 0.5

julia> adjust(pvals, 6, BenjaminiHochberg())
4-element Array{Float64,1}:
 0.006
 0.03
 0.06
 0.75
```
Tokens:
Raw