autocorr.hpp

Go to the documentation of this file.

/*
 * Copyright (C) 1998-2018 ALPS Collaboration. See COPYRIGHT.TXT
 * All rights reserved. Use is subject to license terms. See LICENSE.TXT
 * For use in publications, see ACKNOWLEDGE.TXT
 */
#pragma once

#include <alps/alea/core.hpp>
#include <alps/alea/util.hpp>
#include <alps/alea/variance.hpp>

#include <vector>

// Forward declarations

namespace alps { namespace alea {
    template <typename T> class autocorr_acc;
    template <typename T> class autocorr_result;

    template <typename T> class batch_result;

    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> &);
}}

// Actual declarations

namespace alps { namespace alea {

template <typename T>
class autocorr_acc
{
public:
    using value_type = T;
    using var_type = typename bind<circular_var, T>::var_type;
    using level_acc_type = var_acc<T, circular_var>;

public:
    autocorr_acc(size_t size=1, size_t batch_size=1, size_t granularity=2);

    void reset();

    void set_size(size_t size);

    void set_batch_size(size_t batch_size);

    void set_granularity(size_t granularity);

    bool valid() const { return !level_.empty(); }

    size_t size() const { return size_; }

    autocorr_acc& operator<<(const computed<T>& src){ add(src, 1); return *this; }

    autocorr_acc &operator<<(const autocorr_result<T> &result);

    size_t count() const { return count_; }

    autocorr_result<T> result() const;

    autocorr_result<T> finalize();

    size_t nlevel() const { return level_.size(); }

    const level_acc_type &level(size_t i) const { return level_[i]; }

protected:
    void add(const computed<T> &source, size_t count);

    void add_level();

    void finalize_to(autocorr_result<T> &result);

private:
    size_t size_, batch_size_, count_, nextlevel_, granularity_;
    std::vector<level_acc_type> level_;

    friend class batch_result<T>;
};

template <typename T>
struct traits< autocorr_acc<T> >
{
    typedef T value_type;
    typedef circular_var strategy_type;
    typedef typename bind<circular_var, T>::var_type var_type;
    typedef typename bind<circular_var, T>::cov_type cov_type;
    typedef autocorr_result<T> result_type;
};

extern template class autocorr_acc<double>;
extern template class autocorr_acc<std::complex<double> >;


template <typename T>
class autocorr_result
{
public:
    typedef T value_type;
    typedef typename bind<circular_var, T>::var_type var_type;
    typedef var_result<T, circular_var> level_result_type;

public:
    autocorr_result(size_t nlevel=0) : level_(nlevel) { }

    bool valid() const { return !level_.empty(); }

    size_t size() const { return level_[0].size(); }

    size_t count() const { return level_[0].count(); }

    double count2() const;

    const column<T> &mean() const { return level_[0].mean(); }

    column<var_type> var() const;

    column<var_type> stderror() const;

    column<var_type> tau() const;

    bool tau_available() const { return find_level(DEFAULT_MIN_SAMPLES) > 0; }

    void reduce(const reducer &r) { reduce(r, true, true); }

    friend void serialize<>(serializer &, const std::string &, const autocorr_result &);

    friend void deserialize<>(deserializer &, const std::string &, autocorr_result &);

    friend std::ostream &operator<< <>(std::ostream &, const autocorr_result &);

    size_t find_level(size_t min_samples) const;

    size_t batch_size(size_t level) const;

    size_t nlevel() const { return level_.size(); }

    const level_result_type &level(size_t i) const { return level_[i]; }

    level_result_type &level(size_t i) { return level_[i]; }

protected:
    void reduce(const reducer &r, bool do_pre_commit, bool do_post_commit);

private:
    const static size_t DEFAULT_MIN_SAMPLES = 1024;
    std::vector<level_result_type> level_;

    friend class autocorr_acc<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)
{
    return !operator==(r1, r2);
}

template<typename T> struct is_alea_acc<autocorr_acc<T>> : std::true_type {};
template<typename T> struct is_alea_result<autocorr_result<T>> : std::true_type {};

template <typename T>
struct traits< autocorr_result<T> >
{
    typedef T value_type;
    typedef circular_var strategy_type;
    typedef typename bind<circular_var, T>::var_type var_type;
    typedef typename bind<circular_var, T>::cov_type cov_type;

    const static bool HAVE_MEAN  = true;
    const static bool HAVE_VAR   = true;
    const static bool HAVE_COV   = false;
    const static bool HAVE_TAU   = true;
    const static bool HAVE_BATCH = false;
};

extern template class autocorr_result<double>;
extern template class autocorr_result<std::complex<double> >;

}}