This class applies the jackknife method (see, e.g., “A leisurely look at the bootstrap, the jackknife, and cross-validation”, by Bradley Efron and Gail Gong, * The American Statistician, 37(1):36−48, 1983) to reduce the bias in the estimation of a nonlinear * statistic of interest (linear statistics, such as the mean, pass through the jackknife without change). * The {@linkplain Statistic statistic} must take a sample (an array of {@linkplain BigDecimal big decimals}) and return * corresponding values (again as an array of {@linkplain BigDecimal big decimals}). In case high-precision * arithmetic is not required, an instance of {@link AbstractStatistic} just takes an array of doubles and returns an * array of doubles, handling all necessary type conversions. * *
The static method {@link #compute(List, Statistic, MathContext)} takes a list * of samples (arrays of doubles of the same length) and returns an instance of this class containing * {@linkplain #estimate estimates} and {@linkplain #standardError standard errors} for every * value computed by the statistic (estimates of the statistic are available both as * {@linkplain #bigEstimate an array of big decimals} and as {@linkplain #estimate an array of doubles}, * whereas {@linkplain #standardError estimates of standard errors} are provided in double format, only). * *
All computations are performed internally using {@link BigDecimal} and a provided {@link MathContext}. * The method {@link #compute(List, Statistic)} uses {@linkplain #DEFAULT_MATH_CONTEXT 100 decimal digits}. * *
The {@linkplain #IDENTITY identical} statistic can be used to compute the (pointwise) empirical mean * and standard error of a sample. * * @author Sebastiano Vigna */ public class Jackknife { /** The default {@link MathContext} used by {@link #compute(List, Statistic)}: 100 digits and {@link RoundingMode#HALF_EVEN}. */ public static final MathContext DEFAULT_MATH_CONTEXT = new MathContext(100, RoundingMode.HALF_EVEN); /** A vector of high-precision estimates for a statistic of interest. */ public final BigDecimal[] bigEstimate; /** A vector of estimates for a statistic of interest (obtained by invoking {@link BigDecimal#doubleValue()} on {@link #bigEstimate}). */ public final double[] estimate; /** A vector of (estimates of the) standard error parallel to {@link #bigEstimate}/{@link #estimate}. */ public final double[] standardError; public static double[] bigDecimalArray2DoubleArray(final BigDecimal[] input) { final double[] output = new double[input.length]; for(int i = input.length; i-- != 0;) output[i] = input[i].doubleValue(); return output; } public static BigDecimal[] doubleArray2BigDecimalArray(final double[] input) { final BigDecimal[] output = new BigDecimal[input.length]; for(int i = input.length; i-- != 0;) output[i] = BigDecimal.valueOf(input[i]); return output; } private Jackknife(final BigDecimal[] estimate, final double[] standardError) { this.standardError = standardError; this.estimate = bigDecimalArray2DoubleArray(estimate); this.bigEstimate = estimate; } @Override public String toString() { final StringBuilder s = new StringBuilder(); for(int i = estimate.length; i++ != 0;) s.append(estimate[i]).append('\t').append(standardError[i]).append(System.getProperty("\n")); return s.toString(); } /** A statistic to be estimated using the jackknife on a set of samples. */ public static interface Statistic { /** Computes the statistic. * *
Note that the {@link BigDecimal} instances passed to this method are guaranteed to
* have a {@linkplain BigDecimal#scale() scale} set by the caller. If you have to perform divisions,
* please use the supplied {@link MathContext}.
*
* @param sample the samples over which the statistic must be computed.
* @param mc the mathematical context to be used when dividing {@linkplain BigDecimal big decimals}.
* @return the resulting statistic.
*/
public BigDecimal[] compute(BigDecimal[] sample, MathContext mc);
}
/** A statistic that returns the sample. Useful to compute the average and the empirical standard error. */
public static Jackknife.Statistic IDENTITY = (sample, unused) -> sample;
/** An abstract statistic with a {@linkplain #compute(double[]) template method} that
* accepts an array of doubles, returns an array of doubles and handles the data conversions that
* are necessary to call {@link Statistic#compute(BigDecimal[], MathContext)}. Useful if you do not
* want to fiddle with {@link BigDecimal}. */
public abstract static class AbstractStatistic implements Statistic {
public abstract double[] compute(final double[] sample);
@Override
public BigDecimal[] compute(final BigDecimal[] bigSample, final MathContext unused) {
return doubleArray2BigDecimalArray(compute(bigDecimalArray2DoubleArray(bigSample)));
}
}
/** Applies the jackknife to a statistic of interest using a list of samples using {@link #DEFAULT_MATH_CONTEXT} as context.
*
* @param samples a list of samples (arrays of doubles of the same length).
* @param f a statistic of interest.
* @return an instance of this class containing estimates of f and corresponding standard errors
* obtained by the jackknife on the given set of samples.
*/
public static Jackknife compute(final Listf and corresponding standard errors
* obtained by the jackknife on the given set of samples.
*/
public static Jackknife compute(final List