A class providing various resampling methods for statistical analysis. More...

#include <resampling.hpp>

Static Public Member Functions
static std::vector< int >	bootstrap (const std::vector< int > &data, int numSamples)
	Perform bootstrap resampling. More...

static std::vector< int >	subsample (const std::vector< int > &data, int numSamples)
	Perform subsampling. More...

static std::vector< std::vector< int > >	jackknife (const std::vector< int > &data)
	Perform jackknife resampling. More...

static std::vector< std::vector< int > >	permutation_test (const std::vector< int > &data, int numPermutations)
	Perform permutation test. More...

static std::vector< double >	bootstrap_t (const std::vector< double > &data, int numSamples)
	Perform bootstrap t-statistic resampling. More...

static std::pair< double, double >	bootstrap_ci (const std::vector< double > &data, double alpha, int numSamples)
	Calculate confidence interval using bootstrap. More...

static std::vector< double >	smoothed_bootstrap (const std::vector< double > &data, int numSamples)
	Perform smoothed bootstrap resampling. More...

static std::vector< double >	circular_block_bootstrap (const std::vector< double > &data, int blockSize, int numSamples)
	Perform circular block bootstrap resampling. More...

static std::vector< double >	time_series_bootstrap (const std::vector< double > &data, int numSamples)
	Perform time series bootstrap resampling. More...

static std::vector< double >	weighted_bootstrap (const std::vector< double > &data, const std::vector< double > &weights, int size)
	Perform weighted bootstrap resampling. More...

static double	permutation_p_value (const std::vector< double > &data1, const std::vector< double > &data2, double observedStatistic)
	Calculate the p-value using permutation test. More...

Detailed Description

A class providing various resampling methods for statistical analysis.

Definition at line 48 of file resampling.hpp.

Member Function Documentation

◆ bootstrap()

std::vector< int > gpmp::stats::Resampling::bootstrap	(	const std::vector< int > &	data,
		int	numSamples
	)

static

Perform bootstrap resampling.

Parameters

data	The original data
numSamples	The number of bootstrap samples

Returns: A vector of bootstrap samples

Definition at line 40 of file resampling.cpp.

                                                    {
     std::vector<int> resampledData;
     resampledData.reserve(numSamples);
  
     std::mt19937 rng(std::random_device{}());
     std::uniform_int_distribution<int> dist(0, data.size() - 1);
  
     for (int i = 0; i < numSamples; ++i) {
         int index = dist(rng);
         resampledData.push_back(data[index]);
     }
  
     return resampledData;
 }

◆ bootstrap_ci()

std::pair< double, double > gpmp::stats::Resampling::bootstrap_ci	(	const std::vector< double > &	data,
		double	alpha,
		int	numSamples
	)

static

Calculate confidence interval using bootstrap.

Parameters

data	The original data
alpha	The significance level
numSamples	The number of bootstrap samples

Returns: A pair representing the lower and upper bounds of the confidence interval

Definition at line 137 of file resampling.cpp.

                                                       {
     std::vector<double> resampledMeans = bootstrap_t(data, numSamples);
     std::sort(resampledMeans.begin(), resampledMeans.end());
     int lowerIndex = static_cast<int>((alpha / 2) * numSamples);
     int upperIndex = static_cast<int>((1 - alpha / 2) * numSamples) - 1;
     return std::make_pair(resampledMeans[lowerIndex],
                           resampledMeans[upperIndex]);
 }

◆ bootstrap_t()

std::vector< double > gpmp::stats::Resampling::bootstrap_t	(	const std::vector< double > &	data,
		int	numSamples
	)

static

Perform bootstrap t-statistic resampling.

Parameters

data	The original data
numSamples	The number of bootstrap samples

Returns: A vector of bootstrap t-statistics

Definition at line 111 of file resampling.cpp.

                                                      {
     std::vector<double> resampledMeans;
     resampledMeans.reserve(numSamples);
  
     std::mt19937 rng(std::random_device{}());
     std::uniform_int_distribution<int> dist(0, data.size() - 1);
  
     for (int i = 0; i < numSamples; ++i) {
         std::vector<double> resampledData;
         resampledData.reserve(data.size());
         for (int j = 0; j < static_cast<int>(data.size()); ++j) {
             int index = dist(rng);
             resampledData.push_back(data[index]);
         }
         double mean =
             std::accumulate(resampledData.begin(), resampledData.end(), 0.0) /
             resampledData.size();
         resampledMeans.push_back(mean);
     }
  
     return resampledMeans;
 }

◆ circular_block_bootstrap()

std::vector< double > gpmp::stats::Resampling::circular_block_bootstrap	(	const std::vector< double > &	data,
		int	blockSize,
		int	numSamples
	)

static

Perform circular block bootstrap resampling.

Parameters

data	The original data
blockSize	The size of each block
numSamples	The number of bootstrap samples

Returns: A vector of circular block bootstrap samples

Definition at line 171 of file resampling.cpp.

                     {
  
     if (blockSize <= 0 || blockSize > static_cast<int>(data.size())) {
         throw std::invalid_argument("Invalid block size");
     }
  
     std::vector<double> resampledData;
     resampledData.reserve(numSamples);
  
     std::mt19937 rng(std::random_device{}());
     std::uniform_int_distribution<int> dist(0, data.size() - 1);
  
     for (int i = 0; i < numSamples; ++i) {
         std::vector<double> blockMeans;
         blockMeans.reserve(data.size() / blockSize);
         for (int j = 0; j < static_cast<int>(data.size()) / blockSize; ++j) {
             double sum = 0.0;
             for (int k = 0; k < blockSize; ++k) {
                 int index = dist(rng);
                 sum += data[index];
             }
             blockMeans.push_back(sum / blockSize);
         }
         std::shuffle(blockMeans.begin(), blockMeans.end(), rng);
         resampledData.insert(resampledData.end(),
                              blockMeans.begin(),
                              blockMeans.end());
     }
  
     return resampledData;
 }

◆ jackknife()

std::vector< std::vector< int > > gpmp::stats::Resampling::jackknife ( const std::vector< int > & data )

static

Perform jackknife resampling.

Parameters

data	The original data

Returns: A vector of jackknife resamples

Definition at line 77 of file resampling.cpp.

                                                          {
     int n = data.size();
     std::vector<std::vector<int>> resampledDatasets;
     resampledDatasets.reserve(n);
  
     for (int i = 0; i < n; ++i) {
         std::vector<int> resampledData = data;
         resampledData.erase(resampledData.begin() + i);
         resampledDatasets.push_back(resampledData);
     }
  
     return resampledDatasets;
 }

◆ permutation_p_value()

double gpmp::stats::Resampling::permutation_p_value	(	const std::vector< double > &	data1,
		const std::vector< double > &	data2,
		double	observedStatistic
	)

static

Calculate the p-value using permutation test.

Parameters

data1	The first data set
data2	The second data set
observedStatistic	The observed test statistic

Returns: The permutation p-value

Definition at line 247 of file resampling.cpp.

                                                                        {
     int count = 0;
     std::vector<double> combinedData = data1;
     combinedData.insert(combinedData.end(), data2.begin(), data2.end());
     std::shuffle(combinedData.begin(),
                  combinedData.end(),
                  std::mt19937(std::random_device()()));
     std::vector<double> permutedData1(data1.begin(), data1.end());
     std::vector<double> permutedData2(data2.begin(), data2.end());
     for (int i = 0; i < 1000; ++i) {
         std::shuffle(combinedData.begin(),
                      combinedData.end(),
                      std::mt19937(std::random_device()()));
         auto permutedStatistic =
             (std::accumulate(combinedData.begin(),
                              combinedData.begin() + data1.size(),
                              0.0)) /
             data1.size();
         if (permutedStatistic >= observedStatistic) {
             count++;
         }
     }
     return count / 1000.0;
 }

◆ permutation_test()

std::vector< std::vector< int > > gpmp::stats::Resampling::permutation_test	(	const std::vector< int > &	data,
		int	numPermutations
	)

static

Perform permutation test.

Parameters

data	The original data
numPermutations	The number of permutations

Returns: A vector of permuted data sets

Definition at line 93 of file resampling.cpp.

                                                                {
     std::vector<std::vector<int>> permutedDatasets;
     permutedDatasets.reserve(numPermutations);
  
     std::mt19937 rng(std::random_device{}());
  
     for (int i = 0; i < numPermutations; ++i) {
         std::vector<int> permutedData = data;
         std::shuffle(permutedData.begin(), permutedData.end(), rng);
         permutedDatasets.push_back(permutedData);
     }
  
     return permutedDatasets;
 }

◆ smoothed_bootstrap()

std::vector< double > gpmp::stats::Resampling::smoothed_bootstrap	(	const std::vector< double > &	data,
		int	numSamples
	)

static

Perform smoothed bootstrap resampling.

Parameters

data	The original data
numSamples	The number of bootstrap samples

Returns: A vector of smoothed bootstrap samples

Definition at line 150 of file resampling.cpp.

                                                             {
     std::vector<double> resampledData;
     resampledData.reserve(numSamples);
  
     std::mt19937 rng(std::random_device{}());
     std::uniform_int_distribution<int> dist(0, data.size() - 1);
  
     for (int i = 0; i < numSamples; ++i) {
         double sum = 0.0;
         for (int j = 0; j < static_cast<int>(data.size()); ++j) {
             int index = dist(rng);
             sum += data[index];
         }
         resampledData.push_back(sum / data.size());
     }
  
     return resampledData;
 }

◆ subsample()

std::vector< int > gpmp::stats::Resampling::subsample	(	const std::vector< int > &	data,
		int	numSamples
	)

static

Perform subsampling.

Parameters

data	The original data
numSamples	The number of subsamples

Returns: A vector of subsampled data

Definition at line 58 of file resampling.cpp.

                                                    {
     if (numSamples > static_cast<int>(data.size())) {
         throw std::invalid_argument(
             "Number of samples cannot exceed data size");
     }
  
     std::vector<int> resampledData = data;
     std::shuffle(resampledData.begin(),
                  resampledData.end(),
                  std::mt19937(std::random_device()()));
  
     resampledData.resize(numSamples);
  
     return resampledData;
 }

◆ time_series_bootstrap()

std::vector< double > gpmp::stats::Resampling::time_series_bootstrap	(	const std::vector< double > &	data,
		int	numSamples
	)

static

Perform time series bootstrap resampling.

Parameters

data	The original time series data
numSamples	The number of bootstrap samples

Returns: A vector of time series bootstrap samples

Definition at line 208 of file resampling.cpp.

                                                                {
     std::vector<double> resampledData;
     resampledData.reserve(numSamples);
  
     std::mt19937 rng(std::random_device{}());
     std::uniform_int_distribution<int> dist(0, data.size() - 1);
  
     for (int i = 0; i < numSamples; ++i) {
         std::vector<double> resampledSequence;
         resampledSequence.reserve(data.size());
         int startIndex = dist(rng);
         for (int j = 0; j < static_cast<int>(data.size()); ++j) {
             int index = (startIndex + j) % data.size();
             resampledSequence.push_back(data[index]);
         }
         resampledData.insert(resampledData.end(),
                              resampledSequence.begin(),
                              resampledSequence.end());
     }
  
     return resampledData;
 }

◆ weighted_bootstrap()

std::vector< double > gpmp::stats::Resampling::weighted_bootstrap	(	const std::vector< double > &	data,
		const std::vector< double > &	weights,
		int	size
	)

static

Perform weighted bootstrap resampling.

Parameters

data	The original data
weights	The weights associated with each data point
size	The size of each bootstrap sample

Returns: A vector of weighted bootstrap samples

Definition at line 233 of file resampling.cpp.

                                                       {
     std::vector<double> resampledData;
     std::random_device rd;
     std::mt19937 gen(rd());
     std::discrete_distribution<> dis(weights.begin(), weights.end());
     for (int i = 0; i < size; ++i) {
         resampledData.push_back(data[dis(gen)]);
     }
     return resampledData;
 }

The documentation for this class was generated from the following files:

include/openGPMP/stats/resampling.hpp
modules/stats/resampling.cpp

Static Public Member Functions

Detailed Description

Member Function Documentation

◆ bootstrap()

◆ bootstrap_ci()

◆ bootstrap_t()

◆ circular_block_bootstrap()

◆ jackknife()

◆ permutation_p_value()

◆ permutation_test()

◆ smoothed_bootstrap()

◆ subsample()

◆ time_series_bootstrap()

◆ weighted_bootstrap()