AccumulatorAverageBootstrap

java.lang.Object
- etomica.data.DataProcessor
- - etomica.data.DataProcessorForked
  - - etomica.data.DataAccumulator
    - - etomica.data.AccumulatorAverageBootstrap

All Implemented Interfaces:

DataPipe, DataPipeForked, DataSourceIndependent, IDataSink, IDataSource
```
public class AccumulatorAverageBootstrap
extends DataAccumulator
implements DataSourceIndependent
```
AccumulatorAverage that keeps track of block averages and standard deviations corresponding to all block sizes from 1 to the n where n is the largest power of 2 less than the current number of samples. In addition to block averages and standard deviations of the sampled quantity, a function can be given to the class such that it will compute pass block averages through that function and compute standard deviation of the transformed block averages (this is what makes this class actually useful). The transformed values can be obtained via conventiently named methods with "Log" appended to end. This class can also compute histograms of the block averages for all the different block sizes. The histograms are not returned by any method, but are instead pushed to data sinks.
This class also uses a method to improve the block statistics for large block sizes based on bootstrapping. All block averages are kept for a particular block size (n1 blocks of size b1). Statistics for that block are computed from that data. Block averages for blocks of the next larger size (2*n1) are computed by randomly selecting n1/2 pairs of block values from the b1 set (without including any block value more than once). After using all block values, n1/2 additional pairs are taken from the full b1 set, such that n1 blocks of size b1*2 are obtained, instead of n1/2 blocks that would normally exist. Statistics for block size b1*2 are computed from these n1 blocks. This process is repeated for each block size such that the largest block size (which would normally have 1 block) has n1 blocks.
The class can operate with or without replacement during replacement. Replacement is a standard part of bootstrapping, but does not seem to have a significant impact here due to the way data is built up from small to large block sizes. If replacement is turned off, the resampling goes substantially faster.
This accumulator can only operate on Data with a single value.

Nested Class Summary

Nested Classes
Modifier and Type Class Description

static interface AccumulatorAverageBootstrap.HistogramFactory

Nested Classes
Modifier and Type	Class	Description
`static interface`	`AccumulatorAverageBootstrap.HistogramFactory`

Field Summary

Fields
Modifier and Type	Field	Description
`protected DataFunction`	`averages`
`protected double[]`	`blockSums`
`protected long`	`count`
`protected boolean`	`doUntransform`
`protected AccumulatorAverageBootstrap.HistogramFactory`	`histogramFactory`
`protected java.util.List<Histogram>`	`histogramList`
`protected java.util.List<DataFunction>`	`histograms`
`protected java.util.List<DataFunction.DataInfoFunction>`	`histogramsInfo`
`protected java.util.ArrayList<IDataSink>`	`histogramSinks`
`protected int`	`initialSeed`
`protected java.util.List<java.lang.Integer>`	`intArrayList`
`protected AccumulatorAverageCollapsing`	`lAvg`
`protected DataDouble`	`lData`
`protected DataDouble.DataInfoDouble`	`lDataInfo`
`protected double[][]`	`lSums`
`protected int`	`maxNumBlocks`
`protected DataDoubleArray`	`nData`
`protected DataDoubleArray.DataInfoDoubleArray`	`nDataInfo`
`protected int`	`nMoments`
`protected int`	`nRawData`
`protected int`	`nRawDataDoubles`
`protected DataTag`	`nTag`
`protected IRandom`	`random`
`protected double[]`	`rawData`
`protected double[]`	`rawData2`
`protected double[]`	`rawData3`
`protected int`	`rawDataBlockSize`
`protected DataFunction`	`skew`
`protected DataFunction`	`stdev`
`protected double[][]`	`sums`
`protected IFunction`	`transformFunction`
`protected boolean`	`withReplacement`

Fields inherited from class etomica.data.DataAccumulator
active, hasUnpushedData, pushInterval, putCount

Fields inherited from class etomica.data.DataProcessor
dataInfo, dataSink, tag

Constructor Summary

Constructors
Constructor	Description
`AccumulatorAverageBootstrap()`
`AccumulatorAverageBootstrap(int nMoments)`	With this constructor, the accumulator will use an internal RNG with a set seed such that each resampling of the data will be identical (the same set of samples will go into the averages and the standard deviations, etc).
`AccumulatorAverageBootstrap(IRandom random)`
`AccumulatorAverageBootstrap(IRandom random, int nMoments)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`boolean`	`addData(IData data)`	Add the given values to the sums and block sums.
`protected void`	`doSums(double[] subSums, double v)`	Performs the block sum after
`void`	`enableRawLogStatistics()`
`protected void`	`ensureHappyIntArrayList()`	Refills inArrayList if it's empty.
`IData`	`getAverageLogs()`	Returns the average natural logs of the block averages, for all block sizes.
`IData`	`getAverages()`	Returns the averages for all block sizes
`long`	`getCount()`
`IData`	`getData()`
`int`	`getIndependentArrayDimension()`	Returns the number of independent data dimensions
`DataDoubleArray`	`getIndependentData(int i)`	Returns the X data for the given dimension
`DataDoubleArray.DataInfoDoubleArray`	`getIndependentDataInfo(int i)`	Returns the DataInfo for the given dimension
`DataTag`	`getIndependentTag()`	Returns the tag associated with this DataSource.
`int`	`getNumRawData()`
`double[]`	`getRawData()`
`int`	`getRawDataBlockSize()`
`AccumulatorAverage`	`getRawLogAccumulator()`
`double`	`getSampleLogVariance()`
`double`	`getSampleVariance()`
`IData`	`getSkewLog()`	Returns the standard deviation of the log of the block averages, for all block sizes.
`IData`	`getStdev()`	Returns the standard deviation of the block averages, for all block sizes.
`IData`	`getStdevLog()`	Returns the standard deviation of the log of the block averages, for all block sizes.
`protected void`	`initHistogram(int blockSize, IDataSink sink)`
`static void`	`main(java.lang.String[] args)`
`IData`	`processData(IData inputData)`	Returns getData() every `pushInterval` times it is invoked, otherwise returns null (thereby preventing transmission of data to the next DataSinks).
`IDataInfo`	`processDataInfo(IDataInfo incomingDataInfo)`	Informs this DataProcessor of the DataInfo for the Data it will be processing.
`void`	`pushHistograms()`	Constructs and pushes histograms to any histogram data sink.
`protected void`	`reblockData()`	Reblock data from rawData2 into rawData3, then copy it back to rawData2
`protected void`	`reblockData(int n)`	Brute-force reblock data from rawData into rawData2, taking blocks of size n
`void`	`reset()`	Resets all sums to zero.
`protected void`	`resizeData(int newSize)`
`void`	`setHistogramFactory(AccumulatorAverageBootstrap.HistogramFactory newFactory)`
`void`	`setHistogramSink(int blockSize, IDataSink sink)`	Sets the sink that will receive histograms for a block when pushHistograms is called.
`void`	`setMaxNumBlocks(int newMaxNumBlocks)`	Sets the maximum number of blocks of raw data to be 1<
`void`	`setNumRawDataDoubles(int newNumRawDataDoubles)`	Sets the number of times the random block generation method is used.
`void`	`setTransformFunction(IFunction newFunction)`
`void`	`setUntransformHistograms(boolean doUntransform)`
`void`	`setWithReplacement(boolean newWithReplacement)`
`protected void`	`untransform(double[] x, double[] h, IFunction f)`

Methods inherited from class etomica.data.DataAccumulator
getPushInterval, isActive, setActive, setPushInterval, toString

Methods inherited from interface etomica.data.DataPipe
getTag

Methods inherited from class etomica.data.DataProcessor
getDataInfo, getTag, putData, putDataInfo

Methods inherited from class etomica.data.DataProcessorForked
addDataSink, getDataSink, getDataSinks, removeDataSink, setDataSink, setDataSinks

Methods inherited from interface etomica.data.IDataSink
putData, putDataInfo

Methods inherited from interface etomica.data.IDataSource
getDataInfo, getTag

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - nTag
```
protected final DataTag nTag
```
  - random
```
protected final IRandom random
```
  - nMoments
```
protected final int nMoments
```
  - withReplacement
```
protected boolean withReplacement
```
  - count
```
protected long count
```
  - blockSums
```
protected double[] blockSums
```
  - sums
```
protected double[][] sums
```
  - lSums
```
protected double[][] lSums
```
  - averages
```
protected DataFunction averages
```
  - stdev
```
protected DataFunction stdev
```
  - skew
```
protected DataFunction skew
```
  - nDataInfo
```
protected DataDoubleArray.DataInfoDoubleArray nDataInfo
```
  - nData
```
protected DataDoubleArray nData
```
  - rawData
```
protected double[] rawData
```
  - rawData2
```
protected double[] rawData2
```
  - rawData3
```
protected double[] rawData3
```
  - nRawData
```
protected int nRawData
```
  - rawDataBlockSize
```
protected int rawDataBlockSize
```
  - nRawDataDoubles
```
protected int nRawDataDoubles
```
  - maxNumBlocks
```
protected int maxNumBlocks
```
  - intArrayList
```
protected java.util.List<java.lang.Integer> intArrayList
```
  - initialSeed
```
protected int initialSeed
```
  - lAvg
```
protected AccumulatorAverageCollapsing lAvg
```
  - lData
```
protected DataDouble lData
```
  - lDataInfo
```
protected DataDouble.DataInfoDouble lDataInfo
```
  - histogramList
```
protected java.util.List<Histogram> histogramList
```
  - histogramFactory
```
protected AccumulatorAverageBootstrap.HistogramFactory histogramFactory
```
  - histograms
```
protected final java.util.List<DataFunction> histograms
```
  - histogramsInfo
```
protected final java.util.List<DataFunction.DataInfoFunction> histogramsInfo
```
  - histogramSinks
```
protected final java.util.ArrayList<IDataSink> histogramSinks
```
  - transformFunction
```
protected IFunction transformFunction
```
  - doUntransform
```
protected boolean doUntransform
```
- Constructor Detail
  - AccumulatorAverageBootstrap
```
public AccumulatorAverageBootstrap()
```
  - AccumulatorAverageBootstrap
```
public AccumulatorAverageBootstrap(int nMoments)
```
    With this constructor, the accumulator will use an internal RNG with a set seed such that each resampling of the data will be identical (the same set of samples will go into the averages and the standard deviations, etc).
    
    Parameters:
    
    nMoments - the number of moments handled by the accumulator. should be 2 (standard deviation) or 3 (stdev + skew).
  - AccumulatorAverageBootstrap
```
public AccumulatorAverageBootstrap(IRandom random)
```
  - AccumulatorAverageBootstrap
```
public AccumulatorAverageBootstrap(IRandom random,
                                   int nMoments)
```
    Parameters:
    
    nMoments - the number of moments handled by the accumulator. should be 2 (standard deviation) or 3 (stdev + skew).
- Method Detail
  - setTransformFunction
```
public void setTransformFunction(IFunction newFunction)
```
    Parameters:
    
    newFunction - the transform function, which block averages are passed through.
  - setUntransformHistograms
```
public void setUntransformHistograms(boolean doUntransform)
```
    Parameters:
    
    doUntransform - causes histograms to be untransformed once they are constructed
  - setHistogramFactory
```
public void setHistogramFactory(AccumulatorAverageBootstrap.HistogramFactory newFactory)
```
    Parameters:
    
    newFactory - the factory that makes histograms
  - setHistogramSink
```
public void setHistogramSink(int blockSize,
                             IDataSink sink)
```
    Sets the sink that will receive histograms for a block when pushHistograms is called.
  - setWithReplacement
```
public void setWithReplacement(boolean newWithReplacement)
```
    Parameters:
    
    newWithReplacement - enables sampling with replacement
  - main
```
public static void main(java.lang.String[] args)
```
  - setNumRawDataDoubles
```
public void setNumRawDataDoubles(int newNumRawDataDoubles)
```
    Sets the number of times the random block generation method is used. The number of blocks used will be 2^numRawDataDoubles.
  - setMaxNumBlocks
```
public void setMaxNumBlocks(int newMaxNumBlocks)
```
    Sets the maximum number of blocks of raw data to be 1<
  - processData
```
public IData processData(IData inputData)
```
    Description copied from class: DataAccumulator
    
    Returns getData() every pushInterval times it is invoked, otherwise returns null (thereby preventing transmission of data to the next DataSinks). If isActive is false, data is not accumulated and no action is performed.
    
    Overrides:
    
    processData in class DataAccumulator
    
    Parameters:
    
    inputData - data to be processed.
    
    Returns:
    
    processed data
  - addData
```
public boolean addData(IData data)
```
    Add the given values to the sums and block sums. If any of the given data values is NaN, method returns with no effect on accumulation sums.
    
    Specified by:
    
    addData in class DataAccumulator
    
    Parameters:
    
    data - the data to be processed
    
    Returns:
    
    true if the Accumulator's getData method will now return different data.
  - getCount
```
public long getCount()
```
  - resizeData
```
protected void resizeData(int newSize)
```
  - getData
```
public IData getData()
```
    Specified by:
    
    getData in interface IDataSource
    
    Specified by:
    
    getData in class DataAccumulator
    
    Returns:
    
    the data given by this source
  - untransform
```
protected void untransform(double[] x,
                           double[] h,
                           IFunction f)
```
  - initHistogram
```
protected void initHistogram(int blockSize,
                             IDataSink sink)
```
  - pushHistograms
```
public void pushHistograms()
```
    Constructs and pushes histograms to any histogram data sink.
  - getAverages
```
public IData getAverages()
```
    Returns the averages for all block sizes
  - getAverageLogs
```
public IData getAverageLogs()
```
    Returns the average natural logs of the block averages, for all block sizes.
  - reblockData
```
protected void reblockData()
```
    Reblock data from rawData2 into rawData3, then copy it back to rawData2
  - reblockData
```
protected void reblockData(int n)
```
    Brute-force reblock data from rawData into rawData2, taking blocks of size n
  - ensureHappyIntArrayList
```
protected void ensureHappyIntArrayList()
```
    Refills inArrayList if it's empty.
  - getStdev
```
public IData getStdev()
```
    Returns the standard deviation of the block averages, for all block sizes.
  - getStdevLog
```
public IData getStdevLog()
```
    Returns the standard deviation of the log of the block averages, for all block sizes.
  - getSkewLog
```
public IData getSkewLog()
```
    Returns the standard deviation of the log of the block averages, for all block sizes.
  - doSums
```
protected void doSums(double[] subSums,
                      double v)
```
    Performs the block sum after
  - getNumRawData
```
public int getNumRawData()
```
  - getRawData
```
public double[] getRawData()
```
  - getSampleVariance
```
public double getSampleVariance()
```
  - getSampleLogVariance
```
public double getSampleLogVariance()
```
  - getRawDataBlockSize
```
public int getRawDataBlockSize()
```
  - reset
```
public void reset()
```
    Resets all sums to zero. All statistics are cleared.
    
    Specified by:
    
    reset in class DataAccumulator
  - processDataInfo
```
public IDataInfo processDataInfo(IDataInfo incomingDataInfo)
```
    Description copied from class: DataProcessor
    
    Informs this DataProcessor of the DataInfo for the Data it will be processing. Typically the subclass will use this information to make any objects or otherwise prepare for calls to processData.
    
    Specified by:
    
    processDataInfo in class DataProcessor
    
    Parameters:
    
    incomingDataInfo - the DataInfo of the Data that will be input to this DataProcessor
    
    Returns:
    
    the DataInfo of the Data that will be output by this DataProcessor
  - getIndependentArrayDimension
```
public int getIndependentArrayDimension()
```
    Description copied from interface: DataSourceIndependent
    
    Returns the number of independent data dimensions
    
    Specified by:
    
    getIndependentArrayDimension in interface DataSourceIndependent
  - getIndependentData
```
public DataDoubleArray getIndependentData(int i)
```
    Description copied from interface: DataSourceIndependent
    
    Returns the X data for the given dimension
    
    Specified by:
    
    getIndependentData in interface DataSourceIndependent
  - getIndependentDataInfo
```
public DataDoubleArray.DataInfoDoubleArray getIndependentDataInfo(int i)
```
    Description copied from interface: DataSourceIndependent
    
    Returns the DataInfo for the given dimension
    
    Specified by:
    
    getIndependentDataInfo in interface DataSourceIndependent
  - getIndependentTag
```
public DataTag getIndependentTag()
```
    Description copied from interface: DataSourceIndependent
    
    Returns the tag associated with this DataSource.
    
    Specified by:
    
    getIndependentTag in interface DataSourceIndependent
  - enableRawLogStatistics
```
public void enableRawLogStatistics()
```
  - getRawLogAccumulator
```
public AccumulatorAverage getRawLogAccumulator()
```

Class AccumulatorAverageBootstrap

Nested Class Summary

Field Summary

Fields inherited from class etomica.data.DataAccumulator

Fields inherited from class etomica.data.DataProcessor

Constructor Summary

Method Summary

Methods inherited from class etomica.data.DataAccumulator

Methods inherited from interface etomica.data.DataPipe

Methods inherited from class etomica.data.DataProcessor

Methods inherited from class etomica.data.DataProcessorForked

Methods inherited from interface etomica.data.IDataSink

Methods inherited from interface etomica.data.IDataSource

Methods inherited from class java.lang.Object

Field Detail

nTag

random

nMoments

withReplacement

count

blockSums

sums

lSums

averages

stdev

skew

nDataInfo

nData

rawData

rawData2

rawData3

nRawData

rawDataBlockSize

nRawDataDoubles

maxNumBlocks

intArrayList

initialSeed

lAvg

lData

lDataInfo

histogramList

histogramFactory

histograms

histogramsInfo

histogramSinks

transformFunction

doUntransform

Constructor Detail

AccumulatorAverageBootstrap

AccumulatorAverageBootstrap

AccumulatorAverageBootstrap

AccumulatorAverageBootstrap

Method Detail

setTransformFunction

setUntransformHistograms

setHistogramFactory

setHistogramSink

setWithReplacement

main

setNumRawDataDoubles

setMaxNumBlocks

processData

addData

getCount

resizeData

getData

untransform

initHistogram

pushHistograms

getAverages

getAverageLogs

reblockData

reblockData

ensureHappyIntArrayList

getStdev

getStdevLog

getSkewLog

doSums

getNumRawData

getRawData