summation.h

// -*-c++-*-
#ifndef STORMM_SUMMATION_H
#define STORMM_SUMMATION_H
 
#include <vector>
#include "copyright.h"
#include "Accelerator/hybrid.h"
#include "DataTypes/common_types.h"
#include "DataTypes/stormm_vector_types.h"
#include "UnitTesting/approx.h"
 
namespace stormm {
namespace stmath {
 
using card::Hybrid;
using card::HybridTargetLevel;
using errors::rtErr;
using testing::Approx;
using testing::ComparisonType;

enum class PrefixSumType {
  EXCLUSIVE, INCLUSIVE
};
 
// \brief Compute an in-place prefix sum over a vector.  For "capped" prefix sums, which are
template <typename TBase>
void prefixSumInPlace(TBase* vdata, const size_t n_elements, const PrefixSumType style,
                      const char* caller = nullptr);
 
template <typename TBase>
void prefixSumInPlace(std::vector<TBase> *v, const PrefixSumType style,
                      const char* caller = nullptr);
 
template <typename TBase>
void prefixSumInPlace(Hybrid<TBase> *v, const PrefixSumType style, const char* caller = nullptr);

template <typename TSum, typename TBase>
TSum sum(const TBase* v, const size_t vlen);
 
template <typename TSum, typename TBase>
TSum sum(const std::vector<TBase> &v);
 
template <typename TSum, typename TBase>
TSum sum(const Hybrid<TBase> &hb);
 
template <typename TSum, typename TBase>
TSum sumTuple2(const TBase* v, const size_t vlen);
 
template <typename TSum, typename TBase>
TSum sumTuple2(const std::vector<TBase> &v);
 
template <typename TSum, typename TBase>
TSum sumTuple2(const Hybrid<TBase> &hb);
 
template <typename TSum, typename TBase>
TSum sumTuple3(const TBase* v, const size_t vlen);
 
template <typename TSum, typename TBase>
TSum sumTuple3(const std::vector<TBase> &v);
 
template <typename TSum, typename TBase>
TSum sumTuple3(const Hybrid<TBase> &hb);
 
template <typename TSum, typename TBase>
TSum sumTuple4(const TBase* v, const size_t vlen);
 
template <typename TSum, typename TBase>
TSum sumTuple4(const std::vector<TBase> &v);
 
template <typename TSum, typename TBase>
TSum sumTuple4(const Hybrid<TBase> &hb);

template <typename Ta, typename Tb>
std::vector<Ta> sum(const std::vector<Ta> &va, const std::vector<Tb> &vb, double afac = 1.0,
                    double bfac = 1.0);
 
template <typename Ta, typename Tb, typename Tc>
std::vector<Ta> sum(const std::vector<Ta> &va, const std::vector<Tb> &vb,
                    const std::vector<Tc> &vc, double afac = 1.0, double bfac = 1.0,
                    double cfac = 1.0);
 
template <typename Ta, typename Tb, typename Tc, typename Td>
std::vector<Ta> sum(const std::vector<Ta> &va, const std::vector<Tb> &vb,
                    const std::vector<Tc> &vc, const std::vector<Td> &vd, double afac = 1.0,
                    double bfac = 1.0, double cfac = 1.0, double dfac = 1.0);
 
template <typename Ta, typename Tb>
void sum(Ta* va, const Tb* vb, const size_t length, double afac = 1.0, double bfac = 1.0);
 
template <typename Ta, typename Tb, typename Tc>
void sum(Ta* va, const Tb* vb, const Tc* vc, const size_t length, double afac = 1.0,
         double bfac = 1.0, double cfac = 1.0);
 
template <typename Ta, typename Tb, typename Tc, typename Td>
void sum(Ta* va, const Tb* vb, const Tc* vc, const Td* vd, const size_t length, double afac = 1.0,
         double bfac = 1.0, double cfac = 1.0, double dfac = 1.0);
 
template <typename Ta, typename Tb>
void sum(std::vector<Ta> *va, const std::vector<Tb> &vb, double afac = 1.0, double bfac = 1.0);
 
template <typename Ta, typename Tb, typename Tc>
void sum(std::vector<Ta> *va, const std::vector<Tb> &vb, const std::vector<Tc> &vc,
         double afac = 1.0, double bfac = 1.0, double cfac = 1.0);
 
template <typename Ta, typename Tb, typename Tc, typename Td>
void sum(std::vector<Ta> *va, const std::vector<Tb> &vb, const std::vector<Tc> &vc,
         const std::vector<Td> &vd, double afac = 1.0, double bfac = 1.0, double cfac = 1.0,
         double dfac = 1.0);
 
template <typename Ta, typename Tb>
void sum(Hybrid<Ta> *va, const Hybrid<Tb> &vb, double afac = 1.0, double bfac = 1.0);
 
template <typename Ta, typename Tb, typename Tc>
void sum(Hybrid<Ta> *va, const Hybrid<Tb> &vb, const Hybrid<Tc> &vc, double afac = 1.0,
         double bfac = 1.0, double cfac = 1.0);
 
template <typename Ta, typename Tb, typename Tc, typename Td>
void sum(Hybrid<Ta> *va, const Hybrid<Tb> &vb, const Hybrid<Tc> &vc, const Hybrid<Td> &vd,
         double afac = 1.0, double bfac = 1.0, double cfac = 1.0, double dfac = 1.0);
 
} // namespace stmath
} // namespace stormm
 
#include "summation.tpp"
 
#endif