ALPSCore reference
Namespaces | Classes | Enumerations | Functions
alps::alea Namespace Reference

Set of accumulators and statistical pre-/post-processing operations. More...

Namespaces

 internal
 
 util
 

Classes

class  array_adapter
 
class  autocorr_acc
 
class  autocorr_result
 
class  batch_acc
 
class  batch_data
 
class  batch_result
 
struct  bind
 
struct  bind< circular_var, std::complex< T > >
 
struct  bind< circular_var, T >
 
struct  bind< elliptic_var, std::complex< T > >
 
struct  bind< elliptic_var, T >
 
struct  bootstrap_prop
 
class  bundle
 
struct  circular_var
 
class  column
 
class  complex_op
 
struct  computed
 
class  computed_cmember
 
class  cov_acc
 
class  cov_data
 
class  cov_result
 
struct  deserializer
 
struct  eigen
 
class  eigen_adapter
 
struct  elliptic_var
 
struct  estimate_type_mismatch
 
struct  estimate_unavailable
 
struct  finalized_accumulator
 
class  hdf5_serializer
 
struct  is_alea_acc
 
struct  is_alea_acc< autocorr_acc< T > >
 
struct  is_alea_acc< batch_acc< T > >
 
struct  is_alea_acc< cov_acc< T, circular_var > >
 
struct  is_alea_acc< cov_acc< T, elliptic_var > >
 
struct  is_alea_acc< mean_acc< T > >
 
struct  is_alea_acc< var_acc< T, circular_var > >
 
struct  is_alea_acc< var_acc< T, elliptic_var > >
 
struct  is_alea_result
 
struct  is_alea_result< autocorr_result< T > >
 
struct  is_alea_result< batch_result< T > >
 
struct  is_alea_result< cov_result< T, circular_var > >
 
struct  is_alea_result< cov_result< T, elliptic_var > >
 
struct  is_alea_result< mean_result< T > >
 
struct  is_alea_result< var_result< T, circular_var > >
 
struct  is_alea_result< var_result< T, elliptic_var > >
 
struct  jackknife_prop
 
struct  joiner
 
struct  joiner< autocorr_result< T > >
 
struct  joiner< batch_result< T > >
 
struct  joiner< cov_result< T > >
 
struct  joiner< mean_result< T > >
 
struct  joiner< var_result< T > >
 
struct  linear_prop
 
struct  linear_transformer
 
struct  make_complex
 
struct  make_complex< std::complex< T > >
 
struct  make_real
 
struct  make_real< std::complex< T > >
 
class  mean_acc
 
class  mean_dat
 
class  mean_data
 
class  mean_result
 
struct  mpi_reducer
 
class  ndview
 
struct  no_prop
 
struct  reducer
 
struct  reducer_setup
 
class  result
 
struct  sampling_prop
 
struct  scalar_binary_transformer
 
struct  scalar_unary_transformer
 
struct  serializer
 
struct  size_mismatch
 
class  stream_deserializer
 
class  stream_serializer
 
struct  traits
 
struct  traits< autocorr_acc< T > >
 
struct  traits< autocorr_result< T > >
 
struct  traits< batch_acc< T > >
 
struct  traits< batch_data< T > >
 
struct  traits< batch_result< T > >
 
struct  traits< cov_acc< T, Strategy > >
 
struct  traits< cov_data< T, Strategy > >
 
struct  traits< cov_result< T, Strategy > >
 
struct  traits< mean_acc< T > >
 
struct  traits< mean_data< T > >
 
struct  traits< mean_result< T > >
 
struct  traits< var_acc< T, Strategy > >
 
struct  traits< var_data< T, Strategy > >
 
struct  traits< var_result< T, Strategy > >
 
struct  transformer
 
struct  unsupported_operation
 
class  value_adapter
 
class  var_acc
 
class  var_data
 
class  var_result
 
class  vector_adapter
 
class  view
 
struct  weight_mismatch
 

Enumerations

enum  verbosity { PRINT_TERSE, PRINT_VERBOSE, PRINT_DEBUG }
 

Functions

template<typename T >
void serialize (serializer &, const std::string &, const autocorr_result< T > &)
 
template<typename T >
void deserialize (deserializer &, const std::string &, autocorr_result< T > &)
 
template<typename T >
std::ostream & operator<< (std::ostream &, const autocorr_result< T > &)
 
template<typename T >
bool operator== (const autocorr_result< T > &r1, const autocorr_result< T > &r2)
 
template<typename T >
bool operator!= (const autocorr_result< T > &r1, const autocorr_result< T > &r2)
 
template<typename T >
void serialize (serializer &, const std::string &, const batch_result< T > &)
 
template<typename T >
void deserialize (deserializer &, const std::string &, batch_result< T > &)
 
template<typename T >
std::ostream & operator<< (std::ostream &, const batch_result< T > &)
 
template<typename T >
bool operator== (const batch_result< T > &r1, const batch_result< T > &r2)
 
template<typename T >
bool operator!= (const batch_result< T > &r1, const batch_result< T > &r2)
 
template<typename Derived >
eigen_adapter< typename Derived::Scalar, Derived > make_adapter (const Eigen::DenseBase< Derived > &in)
 
template<typename T >
vector_adapter< T > make_adapter (const std::vector< T > &v)
 
template<typename T , size_t N>
array_adapter< T, N > make_array_adapter (const std::array< T, N > &a)
 
value_adapter< long > make_adapter (size_t v)
 
value_adapter< long > make_adapter (long v)
 
value_adapter< double > make_adapter (double v)
 
template<typename AccType >
std::enable_if< is_alea_acc< AccType >::value, AccType & >::type operator<< (AccType &acc, const typename AccType::value_type &v)
 
template<typename AccType , typename Derived >
std::enable_if< is_alea_acc< AccType >::value, AccType & >::type operator<< (AccType &acc, const Eigen::DenseBase< Derived > &v)
 
template<typename AccType >
std::enable_if< is_alea_acc< AccType >::value, AccType & >::type operator<< (AccType &acc, const std::vector< typename AccType::value_type > &v)
 
template<typename AccType , size_t N>
std::enable_if< is_alea_acc< AccType >::value, AccType & >::type operator<< (AccType &acc, const std::array< typename AccType::value_type, N > &v)
 
template<typename R1 , typename R2 , typename Result = typename internal::joined<R1, R2>::result_type>
Result join (const R1 &first, const R2 &second)
 
template<typename T , typename Str >
void serialize (serializer &, const std::string &, const cov_result< T, Str > &)
 
template<typename T , typename Str >
void deserialize (deserializer &, const std::string &, cov_result< T, Str > &)
 
template<typename T , typename Str >
std::ostream & operator<< (std::ostream &, const cov_result< T, Str > &)
 
template<typename T , typename Strategy >
bool operator== (const cov_result< T, Strategy > &r1, const cov_result< T, Strategy > &r2)
 
template<typename T , typename Strategy >
bool operator!= (const cov_result< T, Strategy > &r1, const cov_result< T, Strategy > &r2)
 
template<typename T >
void serialize (serializer &, const std::string &, const mean_result< T > &)
 
template<typename T >
void deserialize (deserializer &, const std::string &, mean_result< T > &)
 
template<typename T >
std::ostream & operator<< (std::ostream &, const mean_result< T > &)
 
template<typename T >
bool operator== (const mean_result< T > &r1, const mean_result< T > &r2)
 
template<typename T >
bool operator!= (const mean_result< T > &r1, const mean_result< T > &r2)
 
template<typename Archive , typename T >
std::enable_if< is_alea_result< T >::value, void >::type save (Archive &ar, const T &r, const unsigned int)
 
template<typename Archive , typename T >
std::enable_if< is_alea_result< T >::value, void >::type load (Archive &ar, T &r, const unsigned int)
 
template<typename Archive , typename T >
void serialize (Archive &ar, complex_op< T > &co, const unsigned int)
 
template<typename T >
eigen< T >::matrix jacobian (const transformer< T > &f, column< T > x, double dx)
 
template<typename T >
batch_data< T > jackknife (const batch_data< T > &in, const transformer< T > &tf)
 
void serialize (serializer &, const std::string &, const result &)
 
void serialize (serializer &ser, const std::string &key, unsigned long value)
 
void serialize (serializer &ser, const std::string &key, long value)
 
void serialize (serializer &ser, const std::string &key, double value)
 
void serialize (serializer &ser, const std::string &key, std::complex< double > value)
 
template<typename Derived >
void serialize (serializer &ser, const std::string &key, const Eigen::MatrixBase< Derived > &value)
 
void deserialize (deserializer &ser, const std::string &key, unsigned long &value)
 
void deserialize (deserializer &ser, const std::string &key, long &value)
 
void deserialize (deserializer &ser, const std::string &key, double &value)
 
void deserialize (deserializer &ser, const std::string &key, std::complex< double > &value)
 
template<typename T >
void deserialize (deserializer &ser, const std::string &key, Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &value)
 
template<typename T >
void deserialize (deserializer &ser, const std::string &key, Eigen::Matrix< T, Eigen::Dynamic, 1 > &value)
 
template<typename T >
void deserialize (deserializer &ser, const std::string &key, Eigen::Matrix< T, 1, Eigen::Dynamic > &value)
 
template<typename T , typename InResult >
mean_result< T > transform (no_prop, const transformer< T > &tf, const InResult &in)
 
template<typename T , typename InResult >
std::enable_if< traits< InResult >::HAVE_COV, cov_result< T > >::type transform (linear_prop p, const transformer< T > &tf, const InResult &in)
 
template<typename T , typename InResult >
std::enable_if<!traits< InResult >::HAVE_COV, cov_result< T > >::type transform (linear_prop p, const transformer< T > &tf, const InResult &in)
 
template<typename T >
batch_result< T > transform (jackknife_prop, const transformer< T > &tf, const batch_result< T > &in)
 
template batch_result< double > transform (jackknife_prop, const transformer< double > &, const batch_result< double > &)
 
template<typename T >
scalar_unary_transformer< T > make_transformer (std::function< T(T)> fn)
 
template<typename T >
scalar_binary_transformer< T > make_transformer (std::function< T(T, T)> fn)
 
std::ostream & operator<< (std::ostream &stream, verbosity verb)
 
template<typename T , typename Str >
void serialize (serializer &, const std::string &, const var_result< T, Str > &)
 
template<typename T , typename Str >
void deserialize (deserializer &, const std::string &, var_result< T, Str > &)
 
template<typename T , typename Str >
std::ostream & operator<< (std::ostream &, const var_result< T, Str > &)
 
template<typename T , typename Strategy >
bool operator== (const var_result< T, Strategy > &r1, const var_result< T, Strategy > &r2)
 
template<typename T , typename Strategy >
bool operator!= (const var_result< T, Strategy > &r1, const var_result< T, Strategy > &r2)
 
template bool operator== (const autocorr_result< double > &r1, const autocorr_result< double > &r2)
 
template bool operator== (const autocorr_result< std::complex< double >> &r1, const autocorr_result< std::complex< double >> &r2)
 
template void serialize (serializer &, const std::string &key, const autocorr_result< double > &)
 
template void serialize (serializer &, const std::string &key, const autocorr_result< std::complex< double >> &)
 
template void deserialize (deserializer &, const std::string &key, autocorr_result< double > &)
 
template void deserialize (deserializer &, const std::string &key, autocorr_result< std::complex< double > > &)
 
template std::ostream & operator<< (std::ostream &, const autocorr_result< double > &)
 
template std::ostream & operator<< (std::ostream &, const autocorr_result< std::complex< double >> &)
 
template bool operator== (const batch_result< double > &r1, const batch_result< double > &r2)
 
template bool operator== (const batch_result< std::complex< double >> &r1, const batch_result< std::complex< double >> &r2)
 
template void serialize (serializer &, const std::string &key, const batch_result< double > &)
 
template void serialize (serializer &, const std::string &key, const batch_result< std::complex< double >> &)
 
template void deserialize (deserializer &, const std::string &key, batch_result< double > &)
 
template void deserialize (deserializer &, const std::string &key, batch_result< std::complex< double > > &)
 
template std::ostream & operator<< (std::ostream &, const batch_result< double > &)
 
template std::ostream & operator<< (std::ostream &, const batch_result< std::complex< double >> &)
 
template bool operator== (const cov_result< double > &r1, const cov_result< double > &r2)
 
template bool operator== (const cov_result< std::complex< double >, circular_var > &r1, const cov_result< std::complex< double >, circular_var > &r2)
 
template bool operator== (const cov_result< std::complex< double >, elliptic_var > &r1, const cov_result< std::complex< double >, elliptic_var > &r2)
 
template void serialize (serializer &, const std::string &key, const cov_result< double, circular_var > &)
 
template void serialize (serializer &, const std::string &key, const cov_result< std::complex< double >, circular_var > &)
 
template void serialize (serializer &, const std::string &key, const cov_result< std::complex< double >, elliptic_var > &)
 
template void deserialize (deserializer &, const std::string &key, cov_result< double, circular_var > &)
 
template void deserialize (deserializer &, const std::string &key, cov_result< std::complex< double >, circular_var > &)
 
template void deserialize (deserializer &, const std::string &key, cov_result< std::complex< double >, elliptic_var > &)
 
template std::ostream & operator<< (std::ostream &, const cov_result< double, circular_var > &)
 
template std::ostream & operator<< (std::ostream &, const cov_result< std::complex< double >, circular_var > &)
 
template std::ostream & operator<< (std::ostream &, const cov_result< std::complex< double >, elliptic_var > &)
 
template bool operator== (const mean_result< double > &r1, const mean_result< double > &r2)
 
template bool operator== (const mean_result< std::complex< double >> &r1, const mean_result< std::complex< double >> &r2)
 
template void serialize (serializer &, const std::string &, const mean_result< double > &)
 
template void serialize (serializer &, const std::string &, const mean_result< std::complex< double > > &)
 
template void deserialize (deserializer &, const std::string &, mean_result< double > &)
 
template void deserialize (deserializer &, const std::string &, mean_result< std::complex< double > > &)
 
template std::ostream & operator<< (std::ostream &, const mean_result< double > &)
 
template std::ostream & operator<< (std::ostream &, const mean_result< std::complex< double >> &)
 
template eigen< double >::matrix jacobian (const transformer< double > &, column< double >, double)
 
template eigen< std::complex< double > >::matrix jacobian (const transformer< std::complex< double > > &, column< std::complex< double > >, double)
 
template batch_data< double > jackknife (const batch_data< double > &in, const transformer< double > &tf)
 
template batch_data< std::complex< double > > jackknife (const batch_data< std::complex< double > > &in, const transformer< std::complex< double > > &tf)
 
template column< std::complex< double > > result::mean< std::complex< double > > () const
 
template column< double > result::var< std::complex< double >, circular_var > () const
 
template column< complex_op< double > > result::var< std::complex< double >, elliptic_var > () const
 
template eigen< std::complex< double > >::matrix result::cov< std::complex< double >, circular_var > () const
 
template eigen< complex_op< double > >::matrix result::cov< std::complex< double >, elliptic_var > () const
 
template bool operator== (const var_result< double > &r1, const var_result< double > &r2)
 
template bool operator== (const var_result< std::complex< double >, circular_var > &r1, const var_result< std::complex< double >, circular_var > &r2)
 
template bool operator== (const var_result< std::complex< double >, elliptic_var > &r1, const var_result< std::complex< double >, elliptic_var > &r2)
 
template void serialize (serializer &, const std::string &key, const var_result< double, circular_var > &)
 
template void serialize (serializer &, const std::string &key, const var_result< std::complex< double >, circular_var > &)
 
template void serialize (serializer &, const std::string &key, const var_result< std::complex< double >, elliptic_var > &)
 
template void deserialize (deserializer &, const std::string &key, var_result< double, circular_var > &)
 
template void deserialize (deserializer &, const std::string &key, var_result< std::complex< double >, circular_var > &)
 
template void deserialize (deserializer &, const std::string &key, var_result< std::complex< double >, elliptic_var > &)
 
template std::ostream & operator<< (std::ostream &, const var_result< double, circular_var > &)
 
template std::ostream & operator<< (std::ostream &, const var_result< std::complex< double >, circular_var > &)
 
template std::ostream & operator<< (std::ostream &, const var_result< std::complex< double >, elliptic_var > &)
 

Detailed Description

Set of accumulators and statistical pre-/post-processing operations.

Types of accumulators

alps::alea defines a number of accumulators, which differ in the stored statistical estimates and associated runtime and memory cost:

Accumulator Runtime Memory mean var cov tau
mean_acc N k X
var_acc N k X X
cov_acc N k X X X
autocorr_acc a N k log(N) X X X X
batch_acc a N k b X X X (X)

where in the complexity we defined the following terms:

and the following statistcal estimates:

Accumulators and results

Most accumulators (mean_acc) have a matching result class (mean_result). Accumulators and results differ conceptually and thus have almost orthogonal functionality:

To obtain a result from an accumulator, the accumulators provide both a result() and a finalize() method, where

  1. the result() method creates an intermediate result, which leaves the accumulator untouched and thus must involve a copy of the data, while
  2. the finalize() method invalidates the accumulator and thus allows to repurpose its data as the simulation result. The reset() method then re-creates an empty accumulator with the same size.

This can be represented by the following finite state machine: 

                c'tor   _______________
               ------->|               |
result, <<        <<   |     empty     |
 +-------+       +-----|_______________|
 |       |       |            | |
 |     __V_______V____  reset | | reset  ________________
 |    |               |--->---+ +---<---|                |
 +----|  accumulating |                 |     invalid    |
      |_______________|---------------->|________________|
                           finalize
See also
alps::alea::mean_acc<T>::result(), alps::alea::mean_acc<T>::finalize()

Transformation and propagation of uncertainty

Transformations on results can be mediated using the transform method, which takes a transformer instance. Schematically: 

OutResult transform(PropagationStrategy str, Transformer t, InResult in);

Care has to be taken to correctly propagate the uncertainties. alps::alea provides the following strategies, which differ in demand on the results, complexity, and quality of bias correction:

Strategy Prior Bias Requires Invoc.
no_prop any - mean() 1
linear_prop Gauss 1 var() k
sampling_prop Gauss 1/S var() S
jackknife_prop any 1/b batch() b
bootstrap_prop any 1/S batch() S

Transformations must have one argument; functions of multiple random variables (X,Y) can be realized by grouping the arguments together using alps::alea::join and then applying the transform on the combined result.

See also
alps::alea::transform, alps::alea::join

Reduction and serialization

All estimators support reduction (averaging over elements) through the reduce() method, which takes the abstract alps::alea::reducer interface. Depending on the implementation of the reducer, the reduction is performed over different instances (threads, processes, etc.) using MPI, OpenMP, shell etc.

Similarly, all estimators support serialization (converting to permanent format) though the serialize() method, which takes the abstract alps::alea::serializer interface.

See also
alps::alea::reducer, alps::alea::serializer

Enumeration Type Documentation

enum alps::alea::verbosity

Verbosity for printing

Enumerator
PRINT_TERSE 
PRINT_VERBOSE 
PRINT_DEBUG 

Definition at line 55 of file util.hpp.

Function Documentation

template<typename T >
void alps::alea::deserialize ( deserializer &  s,
const std::string &  key,
mean_result< T > &  self 
)

Result to a permanent format (write to disk etc.)

Definition at line 198 of file mean.cpp.

template<typename T >
void alps::alea::deserialize ( deserializer &  s,
const std::string &  key,
autocorr_result< T > &  self 
)

Convert result to a permanent format (write to disk etc.)

Definition at line 262 of file autocorr.cpp.

template<typename T >
void alps::alea::deserialize ( deserializer &  s,
const std::string &  key,
batch_result< T > &  self 
)

Convert result to a permanent format (write to disk etc.)

Definition at line 314 of file batch.cpp.

template<typename T , typename Str >
void alps::alea::deserialize ( deserializer &  s,
const std::string &  key,
cov_result< T, Str > &  self 
)

Definition at line 289 of file covariance.cpp.

template<typename T , typename Str >
void alps::alea::deserialize ( deserializer &  s,
const std::string &  key,
var_result< T, Str > &  self 
)

Definition at line 294 of file variance.cpp.

void alps::alea::deserialize ( deserializer &  ser,
const std::string &  key,
unsigned long &  value 
)
inline

Definition at line 140 of file serialize.hpp.

void alps::alea::deserialize ( deserializer &  ser,
const std::string &  key,
long &  value 
)
inline

Definition at line 143 of file serialize.hpp.

void alps::alea::deserialize ( deserializer &  ser,
const std::string &  key,
double &  value 
)
inline

Definition at line 146 of file serialize.hpp.

void alps::alea::deserialize ( deserializer &  ser,
const std::string &  key,
std::complex< double > &  value 
)
inline

Definition at line 149 of file serialize.hpp.

template<typename T >
void alps::alea::deserialize ( deserializer &  ser,
const std::string &  key,
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &  value 
)

Definition at line 155 of file serialize.hpp.

template<typename T >
void alps::alea::deserialize ( deserializer &  ser,
const std::string &  key,
Eigen::Matrix< T, Eigen::Dynamic, 1 > &  value 
)

Definition at line 163 of file serialize.hpp.

template<typename T >
void alps::alea::deserialize ( deserializer &  ser,
const std::string &  key,
Eigen::Matrix< T, 1, Eigen::Dynamic > &  value 
)

Definition at line 171 of file serialize.hpp.

template void alps::alea::deserialize ( deserializer &  ,
const std::string &  ,
mean_result< double > &   
)
template void alps::alea::deserialize ( deserializer &  ,
const std::string &  ,
mean_result< std::complex< double > > &   
)
template void alps::alea::deserialize ( deserializer &  ,
const std::string &  key,
autocorr_result< double > &   
)
template void alps::alea::deserialize ( deserializer &  ,
const std::string &  key,
autocorr_result< std::complex< double > > &   
)
template void alps::alea::deserialize ( deserializer &  ,
const std::string &  key,
cov_result< double, circular_var > &   
)
template void alps::alea::deserialize ( deserializer &  ,
const std::string &  key,
cov_result< std::complex< double >, circular_var > &   
)
template void alps::alea::deserialize ( deserializer &  ,
const std::string &  key,
cov_result< std::complex< double >, elliptic_var > &   
)
template void alps::alea::deserialize ( deserializer &  ,
const std::string &  key,
var_result< double, circular_var > &   
)
template void alps::alea::deserialize ( deserializer &  ,
const std::string &  key,
var_result< std::complex< double >, circular_var > &   
)
template void alps::alea::deserialize ( deserializer &  ,
const std::string &  key,
var_result< std::complex< double >, elliptic_var > &   
)
template void alps::alea::deserialize ( deserializer &  ,
const std::string &  key,
batch_result< double > &   
)
template void alps::alea::deserialize ( deserializer &  ,
const std::string &  key,
batch_result< std::complex< double > > &   
)
template batch_data<double> alps::alea::jackknife ( const batch_data< double > &  in,
const transformer< double > &  tf 
)
template batch_data<std::complex<double> > alps::alea::jackknife ( const batch_data< std::complex< double > > &  in,
const transformer< std::complex< double > > &  tf 
)
template<typename T >
batch_data< T > alps::alea::jackknife ( const batch_data< T > &  in,
const transformer< T > &  tf 
)

Perform Jackknife transformation to pseudovalues

Definition at line 37 of file propagation.cpp.

template eigen<double>::matrix alps::alea::jacobian ( const transformer< double > &  ,
column< double >  ,
double   
)
template eigen< std::complex<double> >::matrix alps::alea::jacobian ( const transformer< std::complex< double > > &  ,
column< std::complex< double > >  ,
double   
)
template<typename T >
eigen< T >::matrix alps::alea::jacobian ( const transformer< T > &  f,
column< T >  x,
double  dx 
)

Given a function f, estimate its Jacobian J[i,j] = df[i]/dx[j].

Estimate the Jacobian of a transformation f at the point x by forward differences: 

      J[i,j] ~= (f(x + dx e[j]) - f(x))[i] / dx;

where e[j] denotes the j-th unit vector. This procedure is exact for linear transformations and biased otherwise.

Definition at line 13 of file propagation.cpp.

template<typename R1 , typename R2 , typename Result = typename internal::joined<R1, R2>::result_type>
Result alps::alea::join ( const R1 &  first,
const R2 &  second 
)

Joins two statistical results together, assuming their mutual independence.

Returns a result of the random vector which is the concatenation of the random vectors corresponding to the arguments first, second, i.e., of size first.size() + second.size(). Assumes that first and second are uncorrelated (their covariance is zero).

One can combine results of different type; in this case, Result is inferred in such a way that as much information as possible is preserved from the constituent accumulators.

See also
alps::alea::internal::joined

Definition at line 44 of file convert.hpp.

template<typename Archive , typename T >
std::enable_if<is_alea_result<T>::value, void>::type alps::alea::load ( Archive &  ar,
T &  r,
const unsigned  int 
)

This method will be called by Boost/HPX Serialization libraries when deserialization of an ALEA result type is requested.

Definition at line 169 of file stream_serializer.hpp.

template<typename Derived >
eigen_adapter<typename Derived::Scalar, Derived> alps::alea::make_adapter ( const Eigen::DenseBase< Derived > &  in)

Definition at line 34 of file computed.hpp.

template<typename T >
vector_adapter<T> alps::alea::make_adapter ( const std::vector< T > &  v)

Definition at line 41 of file computed.hpp.

value_adapter<long> alps::alea::make_adapter ( size_t  v)
inline

Definition at line 76 of file computed.hpp.

value_adapter<long> alps::alea::make_adapter ( long  v)
inline

Definition at line 81 of file computed.hpp.

value_adapter<double> alps::alea::make_adapter ( double  v)
inline

Definition at line 86 of file computed.hpp.

template<typename T , size_t N>
array_adapter<T,N> alps::alea::make_array_adapter ( const std::array< T, N > &  a)

Definition at line 47 of file computed.hpp.

template<typename T >
scalar_unary_transformer<T> alps::alea::make_transformer ( std::function< T(T)>  fn)

Definition at line 28 of file transformer.hpp.

template<typename T >
scalar_binary_transformer<T> alps::alea::make_transformer ( std::function< T(T, T)>  fn)

Definition at line 34 of file transformer.hpp.

template<typename T >
bool alps::alea::operator!= ( const autocorr_result< T > &  r1,
const autocorr_result< T > &  r2 
)

Definition at line 220 of file autocorr.hpp.

template<typename T >
bool alps::alea::operator!= ( const mean_result< T > &  r1,
const mean_result< T > &  r2 
)

Definition at line 220 of file mean.hpp.

template<typename T >
bool alps::alea::operator!= ( const batch_result< T > &  r1,
const batch_result< T > &  r2 
)

Definition at line 246 of file batch.hpp.

template<typename T , typename Strategy >
bool alps::alea::operator!= ( const var_result< T, Strategy > &  r1,
const var_result< T, Strategy > &  r2 
)

Definition at line 283 of file variance.hpp.

template<typename T , typename Strategy >
bool alps::alea::operator!= ( const cov_result< T, Strategy > &  r1,
const cov_result< T, Strategy > &  r2 
)

Definition at line 289 of file covariance.hpp.

template<typename T >
std::ostream & alps::alea::operator<< ( std::ostream &  str,
const mean_result< T > &  self 
)

Write some info about the result to a stream

Definition at line 223 of file mean.cpp.

template<typename T >
std::ostream & alps::alea::operator<< ( std::ostream &  str,
const autocorr_result< T > &  self 
)

Write some info about the result to a stream

Definition at line 293 of file autocorr.cpp.

template<typename T >
std::ostream & alps::alea::operator<< ( std::ostream &  str,
const batch_result< T > &  self 
)

Write some info about the result to a stream

Definition at line 345 of file batch.cpp.

template<typename T , typename Str >
std::ostream & alps::alea::operator<< ( std::ostream &  str,
const cov_result< T, Str > &  self 
)

Definition at line 320 of file covariance.cpp.

template<typename T , typename Str >
std::ostream & alps::alea::operator<< ( std::ostream &  str,
const var_result< T, Str > &  self 
)

Definition at line 325 of file variance.cpp.

std::ostream & alps::alea::operator<< ( std::ostream &  stream,
verbosity  verb 
)

Changes the verbosity level for printing

Definition at line 11 of file util.cpp.

template<typename AccType >
std::enable_if<is_alea_acc<AccType>::value, AccType&>::type alps::alea::operator<< ( AccType &  acc,
const typename AccType::value_type &  v 
)

Add scalar value to accumulator

Definition at line 213 of file computed.hpp.

template<typename AccType , typename Derived >
std::enable_if<is_alea_acc<AccType>::value, AccType&>::type alps::alea::operator<< ( AccType &  acc,
const Eigen::DenseBase< Derived > &  v 
)

Add Eigen vector-valued expression to accumulator

Definition at line 220 of file computed.hpp.

template<typename AccType >
std::enable_if<is_alea_acc<AccType>::value, AccType&>::type alps::alea::operator<< ( AccType &  acc,
const std::vector< typename AccType::value_type > &  v 
)

Add std::vector to accumulator

Definition at line 227 of file computed.hpp.

template<typename AccType , size_t N>
std::enable_if<is_alea_acc<AccType>::value, AccType&>::type alps::alea::operator<< ( AccType &  acc,
const std::array< typename AccType::value_type, N > &  v 
)

Add std::array to accumulator

Definition at line 234 of file computed.hpp.

template std::ostream& alps::alea::operator<< ( std::ostream &  ,
const mean_result< double > &   
)
template std::ostream& alps::alea::operator<< ( std::ostream &  ,
const mean_result< std::complex< double >> &   
)
template std::ostream& alps::alea::operator<< ( std::ostream &  ,
const autocorr_result< double > &   
)
template std::ostream& alps::alea::operator<< ( std::ostream &  ,
const autocorr_result< std::complex< double >> &   
)
template std::ostream& alps::alea::operator<< ( std::ostream &  ,
const cov_result< double, circular_var > &   
)
template std::ostream& alps::alea::operator<< ( std::ostream &  ,
const cov_result< std::complex< double >, circular_var > &   
)
template std::ostream& alps::alea::operator<< ( std::ostream &  ,
const cov_result< std::complex< double >, elliptic_var > &   
)
template std::ostream& alps::alea::operator<< ( std::ostream &  ,
const var_result< double, circular_var > &   
)
template std::ostream& alps::alea::operator<< ( std::ostream &  ,
const var_result< std::complex< double >, circular_var > &   
)
template std::ostream& alps::alea::operator<< ( std::ostream &  ,
const var_result< std::complex< double >, elliptic_var > &   
)
template std::ostream& alps::alea::operator<< ( std::ostream &  ,
const batch_result< double > &   
)
template std::ostream& alps::alea::operator<< ( std::ostream &  ,
const batch_result< std::complex< double >> &   
)
template bool alps::alea::operator== ( const autocorr_result< double > &  r1,
const autocorr_result< double > &  r2 
)
template bool alps::alea::operator== ( const autocorr_result< std::complex< double >> &  r1,
const autocorr_result< std::complex< double >> &  r2 
)
template bool alps::alea::operator== ( const mean_result< double > &  r1,
const mean_result< double > &  r2 
)
template bool alps::alea::operator== ( const mean_result< std::complex< double >> &  r1,
const mean_result< std::complex< double >> &  r2 
)
template<typename T >
bool alps::alea::operator== ( const autocorr_result< T > &  r1,
const autocorr_result< T > &  r2 
)

Check if two results are identical

Definition at line 136 of file autocorr.cpp.

template bool alps::alea::operator== ( const batch_result< double > &  r1,
const batch_result< double > &  r2 
)
template<typename T >
bool alps::alea::operator== ( const mean_result< T > &  r1,
const mean_result< T > &  r2 
)

Check if two results are identical

Definition at line 145 of file mean.cpp.

template bool alps::alea::operator== ( const batch_result< std::complex< double >> &  r1,
const batch_result< std::complex< double >> &  r2 
)
template bool alps::alea::operator== ( const cov_result< double > &  r1,
const cov_result< double > &  r2 
)
template bool alps::alea::operator== ( const cov_result< std::complex< double >, circular_var > &  r1,
const cov_result< std::complex< double >, circular_var > &  r2 
)
template bool alps::alea::operator== ( const cov_result< std::complex< double >, elliptic_var > &  r1,
const cov_result< std::complex< double >, elliptic_var > &  r2 
)
template bool alps::alea::operator== ( const var_result< double > &  r1,
const var_result< double > &  r2 
)
template bool alps::alea::operator== ( const var_result< std::complex< double >, circular_var > &  r1,
const var_result< std::complex< double >, circular_var > &  r2 
)
template bool alps::alea::operator== ( const var_result< std::complex< double >, elliptic_var > &  r1,
const var_result< std::complex< double >, elliptic_var > &  r2 
)
template<typename T >
bool alps::alea::operator== ( const batch_result< T > &  r1,
const batch_result< T > &  r2 
)

Check if two results are identical

Definition at line 212 of file batch.cpp.

template<typename T , typename Strategy >
bool alps::alea::operator== ( const var_result< T, Strategy > &  r1,
const var_result< T, Strategy > &  r2 
)

Check if two results are identical

Definition at line 225 of file variance.cpp.

template<typename T , typename Strategy >
bool alps::alea::operator== ( const cov_result< T, Strategy > &  r1,
const cov_result< T, Strategy > &  r2 
)

Check if two results are identical

Definition at line 219 of file covariance.cpp.

template eigen<std::complex<double> >::matrix alps::alea::result::cov< std::complex< double >, circular_var > ( ) const
template eigen<complex_op<double> >::matrix alps::alea::result::cov< std::complex< double >, elliptic_var > ( ) const
template column<std::complex<double> > alps::alea::result::mean< std::complex< double > > ( ) const
template column<double> alps::alea::result::var< std::complex< double >, circular_var > ( ) const
template column<complex_op<double> > alps::alea::result::var< std::complex< double >, elliptic_var > ( ) const
template<typename Archive , typename T >
std::enable_if<is_alea_result<T>::value, void>::type alps::alea::save ( Archive &  ar,
const T &  r,
const unsigned  int 
)

This method will be called by Boost/HPX Serialization libraries when serialization of an ALEA result type is requested.

Definition at line 158 of file stream_serializer.hpp.

void alps::alea::serialize ( serializer &  s,
const std::string &  key,
const result &  result 
)

Convert result to a permanent format (write to disk etc.)

Definition at line 168 of file result.cpp.

template<typename T >
void alps::alea::serialize ( serializer &  s,
const std::string &  key,
const mean_result< T > &  self 
)

Convert result to a permanent format (write to disk etc.)

Definition at line 185 of file mean.cpp.

template<typename T >
void alps::alea::serialize ( serializer &  s,
const std::string &  key,
const autocorr_result< T > &  self 
)

Convert result to a permanent format (write to disk etc.)

Definition at line 243 of file autocorr.cpp.

template<typename T >
void alps::alea::serialize ( serializer &  s,
const std::string &  key,
const batch_result< T > &  self 
)

Convert result to a permanent format (write to disk etc.)

Definition at line 294 of file batch.cpp.

template<typename T , typename Str >
void alps::alea::serialize ( serializer &  s,
const std::string &  key,
const cov_result< T, Str > &  self 
)

Definition at line 273 of file covariance.cpp.

template<typename T , typename Str >
void alps::alea::serialize ( serializer &  s,
const std::string &  key,
const var_result< T, Str > &  self 
)

Definition at line 278 of file variance.cpp.

void alps::alea::serialize ( serializer &  ser,
const std::string &  key,
unsigned long  value 
)
inline

Definition at line 91 of file serialize.hpp.

void alps::alea::serialize ( serializer &  ser,
const std::string &  key,
long  value 
)
inline

Definition at line 94 of file serialize.hpp.

void alps::alea::serialize ( serializer &  ser,
const std::string &  key,
double  value 
)
inline

Definition at line 97 of file serialize.hpp.

void alps::alea::serialize ( serializer &  ser,
const std::string &  key,
std::complex< double >  value 
)
inline

Definition at line 100 of file serialize.hpp.

template<typename Derived >
void alps::alea::serialize ( serializer &  ser,
const std::string &  key,
const Eigen::MatrixBase< Derived > &  value 
)

Definition at line 106 of file serialize.hpp.

template<typename Archive , typename T >
void alps::alea::serialize ( Archive &  ar,
complex_op< T > &  co,
const unsigned  int 
)

Serialize/deserialize alps::alea::complex_op<T>. Called by Boost/HPX Serialization libraries.

Definition at line 179 of file stream_serializer.hpp.

template void alps::alea::serialize ( serializer &  ,
const std::string &  ,
const mean_result< double > &   
)
template void alps::alea::serialize ( serializer &  ,
const std::string &  ,
const mean_result< std::complex< double > > &   
)
template void alps::alea::serialize ( serializer &  ,
const std::string &  key,
const autocorr_result< double > &   
)
template void alps::alea::serialize ( serializer &  ,
const std::string &  key,
const autocorr_result< std::complex< double >> &   
)
template void alps::alea::serialize ( serializer &  ,
const std::string &  key,
const cov_result< double, circular_var > &   
)
template void alps::alea::serialize ( serializer &  ,
const std::string &  key,
const cov_result< std::complex< double >, circular_var > &   
)
template void alps::alea::serialize ( serializer &  ,
const std::string &  key,
const cov_result< std::complex< double >, elliptic_var > &   
)
template void alps::alea::serialize ( serializer &  ,
const std::string &  key,
const var_result< double, circular_var > &   
)
template void alps::alea::serialize ( serializer &  ,
const std::string &  key,
const var_result< std::complex< double >, circular_var > &   
)
template void alps::alea::serialize ( serializer &  ,
const std::string &  key,
const var_result< std::complex< double >, elliptic_var > &   
)
template void alps::alea::serialize ( serializer &  ,
const std::string &  key,
const batch_result< double > &   
)
template void alps::alea::serialize ( serializer &  ,
const std::string &  key,
const batch_result< std::complex< double >> &   
)
template<typename T , typename InResult >
mean_result<T> alps::alea::transform ( no_prop  ,
const transformer< T > &  tf,
const InResult &  in 
)

Definition at line 27 of file transform.hpp.

template<typename T , typename InResult >
std::enable_if<traits<InResult>::HAVE_COV, cov_result<T> >::type alps::alea::transform ( linear_prop  p,
const transformer< T > &  tf,
const InResult &  in 
)

Definition at line 45 of file transform.hpp.

template<typename T , typename InResult >
std::enable_if<!traits<InResult>::HAVE_COV, cov_result<T> >::type alps::alea::transform ( linear_prop  p,
const transformer< T > &  tf,
const InResult &  in 
)

Definition at line 73 of file transform.hpp.

template<typename T >
batch_result<T> alps::alea::transform ( jackknife_prop  ,
const transformer< T > &  tf,
const batch_result< T > &  in 
)

Definition at line 101 of file transform.hpp.

template batch_result<double> alps::alea::transform ( jackknife_prop  ,
const transformer< double > &  ,
const batch_result< double > &   
)
Generated on Sun Oct 14 2018 12:18:31 for ALPSCore reference by   doxygen 1.8.11