size_products.hpp

Go to the documentation of this file.

#ifndef FIMS_POPULATION_DYNAMICS_SIZE_PRODUCTS_HPP
#define FIMS_POPULATION_DYNAMICS_SIZE_PRODUCTS_HPP
 
#include <cstddef>
#include <stdexcept>
 
#include "../../common/fims_vector.hpp"
 
namespace fims_popdy {

template <typename Type>
struct SizeProducts {
  std::size_t n_years = 0; 
  std::size_t n_ages = 0;  
  std::size_t n_size_bins =
      0; 
 
  fims::Vector<Type> mean_LAA; 
  fims::Vector<Type>
      sd_LAA; 
  fims::Vector<Type>
      prob_size; 

  SizeProducts() {}

  SizeProducts(std::size_t years, std::size_t ages, std::size_t size_bins) {
    Resize(years, ages, size_bins);
  }

  void Resize(std::size_t years, std::size_t ages, std::size_t size_bins) {
    n_years = years;
    n_ages = ages;
    n_size_bins = size_bins;
 
    const std::size_t n_age_year = n_years * n_ages;
    const std::size_t n_prob = n_years * n_ages * n_size_bins;
 
    mean_LAA.resize(n_age_year);
    sd_LAA.resize(n_age_year);
    prob_size.resize(n_prob);
  }

  void ResizeProbSizeOnly(std::size_t years, std::size_t ages,
                          std::size_t size_bins) {
    n_years = years;
    n_ages = ages;
    n_size_bins = size_bins;
 
    mean_LAA.clear();
    sd_LAA.clear();
 
    const std::size_t n_prob = n_years * n_ages * n_size_bins;
    prob_size.resize(n_prob);
  }

  inline std::size_t AgeYearIndex(std::size_t year_index,
                                  std::size_t age_index) const {
    if (year_index >= n_years || age_index >= n_ages) {
      throw std::out_of_range("SizeProducts year-age index out of range");
    }
 
    return year_index * n_ages + age_index;
  }

  inline std::size_t AgeYearSizeIndex(std::size_t year_index,
                                      std::size_t age_index,
                                      std::size_t size_bin_index) const {
    if (year_index >= n_years || age_index >= n_ages ||
        size_bin_index >= n_size_bins) {
      throw std::out_of_range("SizeProducts year-age-size index out of range");
    }
 
    return year_index * (n_ages * n_size_bins) + age_index * n_size_bins +
           size_bin_index;
  }

  inline Type& MeanLAA(std::size_t year_index, std::size_t age_index) {
    return mean_LAA[AgeYearIndex(year_index, age_index)];
  }

  inline Type& SdLAA(std::size_t year_index, std::size_t age_index) {
    return sd_LAA[AgeYearIndex(year_index, age_index)];
  }

  inline Type& ProbSize(std::size_t year_index, std::size_t age_index,
                        std::size_t size_bin_index) {
    return prob_size[AgeYearSizeIndex(year_index, age_index, size_bin_index)];
  }

  inline const Type& MeanLAA(std::size_t year_index,
                             std::size_t age_index) const {
    return mean_LAA[AgeYearIndex(year_index, age_index)];
  }

  inline const Type& SdLAA(std::size_t year_index,
                           std::size_t age_index) const {
    return sd_LAA[AgeYearIndex(year_index, age_index)];
  }

  inline const Type& ProbSize(std::size_t year_index, std::size_t age_index,
                              std::size_t size_bin_index) const {
    return prob_size[AgeYearSizeIndex(year_index, age_index, size_bin_index)];
  }
};
 
}  // namespace fims_popdy
 
#endif /* FIMS_POPULATION_DYNAMICS_SIZE_PRODUCTS_HPP */