mean.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/computed.hpp>

#include <memory>

// Forward declarations

namespace alps { namespace alea {
    template <typename T> class mean_data;
    template <typename T> class mean_acc;
    template <typename T> class mean_result;

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

// Actual declarations

namespace alps { namespace alea {

template <typename T>
class mean_data
{
public:
    mean_data(size_t size) : data_(size) { reset(); }

    void reset();

    size_t size() const { return data_.rows(); }

    size_t count() const { return count_; }

    size_t &count() { return count_; }

    const column<T> &data() const { return data_; }

    column<T> &data() { return data_; }

    void convert_to_mean();

    void convert_to_sum();

private:
    column<T> data_;
    size_t count_;

    friend class mean_acc<T>;
    friend class mean_result<T>;
    friend void serialize<>(serializer &, const std::string &, const mean_result<T> &);
    friend void deserialize<>(deserializer &, const std::string &, mean_result<T> &);
};

template <typename T>
struct traits< mean_data<T> >
{
    typedef T value_type;
};

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


template <typename T>
class mean_acc
{
public:
    using value_type = T;

public:
    mean_acc(size_t size=1) : store_(new mean_data<T>(size)), size_(size) { }

    mean_acc(const mean_acc &other);

    mean_acc &operator=(const mean_acc &other);

    void reset();

    void set_size(size_t size);

    bool valid() const { return (bool)store_; }

    size_t size() const { return size_; }

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

    mean_acc &operator<<(const mean_result<T> &result);

    size_t count() const { return store_->count(); }

    mean_result<T> result() const;

    mean_result<T> finalize();

    const mean_data<T> &store() const { return *store_; }

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

    void finalize_to(mean_result<T> &result);

private:
    std::unique_ptr< mean_data<T> > store_;
    size_t size_;
};

template <typename T>
struct traits< mean_acc<T> >
{
    typedef T value_type;
    typedef mean_result<T> result_type;
    typedef mean_data<T> store_type;
};

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

template <typename T>
class mean_result
{
public:
    mean_result() { }

    mean_result(const mean_data<T> &acc_data)
        : store_(new mean_data<T>(acc_data))
    { }

    mean_result(const mean_result &other);

    mean_result &operator=(const mean_result &other);

    bool valid() const { return (bool)store_; }

    size_t size() const { return store_->size(); }

    size_t count() const { return store_->count(); }

    const column<T> &mean() const { return store_->data(); }

    const mean_data<T> &store() const { return *store_; }

    mean_data<T> &store() { return *store_; }

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

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

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

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

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

private:
    std::unique_ptr< mean_data<T> > store_;

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

template<typename T> struct is_alea_acc<mean_acc<T>> : std::true_type {};
template<typename T> struct is_alea_result<mean_result<T>> : std::true_type {};

template <typename T>
struct traits< mean_result<T> >
{
    typedef T value_type;

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

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

}}