vectors.hpp

Go to the documentation of this file.

 
#pragma once
#include <algorithm>
#include <random>
#include <string>
#include <vector>
 
namespace hmap
{
 
std::vector<size_t> argsort(const std::vector<float> &v);
 
float compute_median(std::vector<float> values);
 
std::vector<size_t> find_sign_changes(const std::vector<float> &data);
 
std::vector<float> generate_random_vector(size_t   size,
                                          float    min_value,
                                          float    max_value,
                                          uint32_t seed);
 
std::vector<int> generate_random_vector(size_t   size,
                                        int      min_value,
                                        int      max_value,
                                        uint32_t seed);
 
std::vector<int> generate_unique_random_vector(size_t   size,
                                               int      min_value,
                                               int      max_value,
                                               uint32_t seed);
 
std::string make_histogram(const std::vector<float> &values,
                           int                       bin_count,
                           int                       hist_height);
 
std::vector<float> moving_average(const std::vector<float> &input, int radius);
 
template <typename T>
void reindex_vector(std::vector<T> &v, std::vector<size_t> &idx)
{
  std::vector<T> v_new(v.size());
  for (std::uint32_t k = 0; k < v.size(); k++)
    v_new[k] = v[idx[k]];
  v = v_new;
}
 
std::vector<float> remap(const std::vector<float> &data,
                         float                     new_min = 0.f,
                         float                     new_max = 1.f);
 
template <typename T>
void shuffle_vector(std::vector<T> &values, std::uint32_t seed)
{
  std::mt19937 rng(seed);
  std::shuffle(values.begin(), values.end(), rng);
}
 
template <typename T>
std::vector<T> shuffled_vector(const std::vector<T> &values, std::uint32_t seed)
{
  std::vector<T> result = values;
  shuffle_vector(result, seed);
  return result;
}
 
size_t upperbound_right(const std::vector<float> &v, float value);
 
void vector_unique_values(std::vector<float> &v);
 
} // namespace hmap