accumulate_functors.hpp

Go to the documentation of this file.

//=======================================================================
// Copyright (c) 2014 Andrzej Pacuk
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//=======================================================================
#ifndef PAAL_ACCUMULATE_FUNCTORS_HPP
#define PAAL_ACCUMULATE_FUNCTORS_HPP

#include "paal/utils/functors.hpp"
#include "paal/utils/type_functions.hpp"

#include <boost/range/adaptor/transformed.hpp>
#include <boost/range/algorithm/max_element.hpp>
#include <boost/range/algorithm/min_element.hpp>
#include <boost/range/numeric.hpp>

namespace paal {

template <
    typename Range,
    typename T,
    typename Functor,
    typename BinaryOperation = utils::plus>
T accumulate_functor(
    const Range& rng,
    T init,
    Functor f,
    BinaryOperation bin_op = BinaryOperation{}) {
    return boost::accumulate(
        rng | boost::adaptors::transformed(f),
        init,
        bin_op);
}

template <typename Range, typename Functor>
auto sum_functor(const Range& rng, Functor f) {
    using T = pure_result_of_t<Functor(range_to_elem_t<Range>)>;
    return accumulate_functor(rng, T{}, f);
}

template <typename Range, typename Functor>
auto max_element_functor(Range&& range, Functor f) {
    auto unsafe_to_return_iterator = boost::max_element(
            std::forward<Range>(range) |
            boost::adaptors::transformed(utils::make_assignable_functor(f)));
    return boost::make_transform_iterator(unsafe_to_return_iterator.base(), f);
}

template <typename Range, typename Functor>
auto min_element_functor(Range&& range, Functor f) {
    auto unsafe_to_return_iterator = boost::min_element(
            std::forward<Range>(range) |
            boost::adaptors::transformed(utils::make_assignable_functor(f)));
    return boost::make_transform_iterator(unsafe_to_return_iterator.base(), f);
}

template <typename ValueType = double, typename CounterType = std::size_t>
class average_accumulator {
    ValueType m_accumulated_value;
    CounterType m_cnt;

public:
    template<class Archive>
    void serialize(Archive & ar, const unsigned int version) {
        ar & m_accumulated_value;
        ar & m_cnt;
    }

    average_accumulator(ValueType value = ValueType{},
                        CounterType cnt = CounterType{}) :
        m_accumulated_value(value), m_cnt(cnt) {
    }

    bool operator==(average_accumulator other) const {
        return m_accumulated_value == other.m_accumulated_value &&
               m_cnt == other.m_cnt;
    }

    void add_value(ValueType value, CounterType cnt = 1) {
        m_accumulated_value += value;
        m_cnt += cnt;
    }

    average_accumulator& operator+=(const average_accumulator &accumulator) {
        add_value(accumulator.m_accumulated_value, accumulator.m_cnt);
        return *this;
    }

    ValueType get_accumulated_value() const {
        return m_accumulated_value;
    }

    CounterType get_count() const {
        return m_cnt;
    }

    bool empty() const {
        return m_cnt == 0;
    }

    template <typename ReturnType = double>
    ReturnType get_average_unsafe() const {
        return static_cast<ReturnType>(m_accumulated_value) / m_cnt;
    }

    template <typename ReturnType = double>
    ReturnType get_average(ReturnType default_value = ReturnType{}) const {
        if (m_cnt) {
            return get_average_unsafe();
        } else {
            return default_value;
        }
    }

};

} 
#endif /* PAAL_ACCUMULATE_FUNCTORS_HPP */