series_ops.h

// -*-c++-*-
#ifndef STORMM_SET_OPS_H
#define STORMM_SET_OPS_H
 
#include <vector>
#include "copyright.h"
#include "Accelerator/hybrid.h"
#include "Constants/scaling.h"
#include "DataTypes/common_types.h"
#include "Parsing/parse.h"
#include "Parsing/polynumeric.h"
#include "summation.h"
#include "vector_ops.h"
 
namespace stormm {
namespace stmath {
 
using card::Hybrid;
using parse::NumberFormat;
using parse::realToString;

template <typename T> std::vector<T> incrementingSeries(const T start_value, const T end_value,
                                                        const T increment = 1);
  
std::vector<uint> numberSeriesToBitMask(const int* number_series, const size_t length,
                                        int output_size = 0);
 
std::vector<uint> numberSeriesToBitMask(const std::vector<int> &number_series,
                                        int output_size = 0);
 
std::vector<uint> numberSeriesToBitMask(const Hybrid<int> &number_series, int output_size = 0);

std::vector<int> getSubsetIndexPattern(std::vector<int> *x_subset, int x_size,
                                       int *n_subset_indices = nullptr);

template <typename T> std::vector<T> extractIndexedValues(const T* original_values,
                                                          size_t values_length,
                                                          const std::vector<int> reduced_indices,
                                                          const int reduced_length = 0);
 
template <typename T> std::vector<T> extractIndexedValues(const std::vector<T> &original_values,
                                                          const std::vector<int> reduced_indices,
                                                          const int reduced_length = 0);
 
template <typename T> std::vector<T> extractIndexedValues(const Hybrid<T> &original_values,
                                                          const std::vector<int> reduced_indices,
                                                          const int reduced_length = 0);
  
template <typename Tdata, typename Tloc>
void indexingArray(const Tdata* raw_values, Tloc* value_locations, Tloc* value_bounds,
                   size_t value_count, size_t value_limit);
 
template <typename Tdata, typename Tloc>
void indexingArray(const std::vector<Tdata> &raw_values, std::vector<Tloc> *value_locations,
                   std::vector<Tloc> *value_bounds, size_t value_limit = 0);
 
template <typename Tdata, typename Tloc>
void indexingArray(const Hybrid<Tdata> &raw_values, Hybrid<Tloc> *value_locations,
                   Hybrid<Tloc> *value_bounds, size_t value_limit = 0);

std::vector<int> enumerateMask(const std::vector<bool> &bitmask);
 
std::vector<int> enumerateMask(const uint* bitmask, const int length);
 
std::vector<int> enumerateMask(const std::vector<uint> &bitmask);
 
std::vector<int> enumerateMask(const Hybrid<uint> &bitmask);
 
  
} // namespace stmath
} // namespace stormm
 
#include "series_ops.tpp"
 
#endif