HistoryBase.hpp

// Copyright 2021 Arnaud Becheler    <abechele@umich.edu>
 
/*********************************************************************** * This program is free software; you can
 *redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free
 *Software Foundation; either version 2 of the License, or    * (at your option) any later version. *
 *                                                                      *
 ***************************************************************************/
 
#ifndef __BASE_HISTORY_H_INCLUDED__
#define __BASE_HISTORY_H_INCLUDED__
 
#include "../utils/random/DiscreteDistribution.hpp" // BackwardKernel
 
#include <functional> // std::cref
#include <memory>     // unique_ptr
#include <vector>
 
namespace quetzal
{
namespace demography
{
template <typename Space, typename DemographicPolicy, typename MemoryPolicy> class HistoryBase
{
  public:
    using coord_type = Space;
    using time_type = unsigned int;
    using memory_policy = MemoryPolicy;
    using demographic_policy = DemographicPolicy;
    using value_type = typename demographic_policy::value_type;
    using flow_type = typename memory_policy::template flow_type<coord_type, time_type, value_type>;
    using pop_sizes_type = typename memory_policy::template pop_sizes_type<coord_type, time_type, value_type>;
    using discrete_distribution_type = quetzal::utils::random::DiscreteDistribution<coord_type>;
    HistoryBase(coord_type const &x, value_type N, unsigned int nb_generations)
        : m_nb_generations(nb_generations), m_sizes(std::make_unique<pop_sizes_type>()),
          m_flows(std::make_unique<flow_type>())
    {
        m_sizes->set(x, 0, N);
    }
    auto distribution_area(time_type t) const
    {
        return m_sizes->definition_space(t);
    }
    auto &pop_size(coord_type const &x, time_type const &t)
    {
        return m_sizes->operator()(x, t);
    }
    auto get_functor_N() const noexcept
    {
        auto N_ref = std::cref(this->m_sizes);
        return [N_ref](coord_type const &x, time_type t) { return N_ref.get()->get(x, t); };
    }
    auto get_pop_size(coord_type const &x, time_type const &t)
    {
        return m_sizes->get(x, t);
    }
    void set_pop_size(coord_type const &x, time_type const &t, value_type N)
    {
        m_sizes->set(x, t, N);
    }
    unsigned int const &nb_generations() const
    {
        return m_nb_generations;
    }
    template <typename Generator> coord_type backward_kernel(coord_type const &x, time_type t, Generator &gen) const
    {
        --t;
        assert(m_flows->flow_to_is_defined(x, t));
        auto k = make_backward_distribution(x, t);
        return k(gen);
    }
 
  protected:
    // Need to be accessed by the expand method
    std::unique_ptr<flow_type> m_flows;
 
  private:
    unsigned int m_nb_generations;
    std::unique_ptr<pop_sizes_type> m_sizes;
    auto make_backward_distribution(coord_type const &x, time_type const &t) const
    {
        std::vector<double> weights;
        std::vector<coord_type> support;
        weights.reserve(m_flows->flow_to(x, t).size());
        support.reserve(m_flows->flow_to(x, t).size());
        for (auto const &it : m_flows->flow_to(x, t))
        {
            support.push_back(it.first);
            weights.push_back(static_cast<double>(it.second));
        }
        return discrete_distribution_type(std::move(support), std::move(weights));
    }
}; // end HistoryBase
} // namespace demography
} // namespace quetzal
 
#endif