vecMethods.h

Go to the documentation of this file.

/*
 * -------------------------------------------
 * Copyright (c) 2021 - 2026 Prashant K. Jha
 * -------------------------------------------
 * PeriDEM https://github.com/prashjha/PeriDEM
 *
 * Distributed under the Boost Software License, Version 1.0. (See accompanying
 * file LICENSE)
 */
 
#pragma once
 
#include "point.h"           // definition of Point
#include <cstdint> // uint8_t type
#include <cstring> // string and size_t type
#include <vector>
#include "util/io.h"
#include <stdexcept>
#include <chrono>
#include <numeric>      // std::iota
#include <algorithm>    // std::sort, std::stable_sort
#include <map>
 
using namespace std::chrono;
 
namespace util {
 
namespace methods {
 
template <typename T>
inline size_t maxIndex(const std::vector<T> &data) {
 
      // initialize original index locations
      std::vector<size_t> idx(data.size());
      std::iota(idx.begin(), idx.end(), 0);
 
      std::stable_sort(idx.begin(), idx.end(),
                       [&data](size_t i1, size_t i2) {return data[i1] > data[i2];});
 
      return idx[0];
};
 
template <typename T>
inline size_t minIndex(const std::vector<T> &data) {
 
      // initialize original index locations
      std::vector<size_t> idx(data.size());
      std::iota(idx.begin(), idx.end(), 0);
 
      std::stable_sort(idx.begin(), idx.end(),
                       [&data](size_t i1, size_t i2) {return data[i1] < data[i2];});
 
      return idx[0];
};
 
template <typename T>
inline T max(const std::vector<T> &data) {
      return data[util::methods::maxIndex(data)];
};
 
template <typename T>
inline T min(const std::vector<T> &data) {
      return data[util::methods::minIndex(data)];
};
 
template <typename T>
inline std::pair<size_t, T> maxAndMaxIndex(const std::vector<T> &data) {
      auto i = util::methods::maxIndex(data);
      return {data[i], i};
};
 
template <typename T>
inline std::pair<size_t, T> minAndMinIndex(const std::vector<T> &data) {
      auto i = util::methods::minIndex(data);
      return {data[i], i};
};
 
 
template <typename T>
inline size_t maxIndex(const std::vector<T> &data,
                       size_t data_start, size_t data_end) {
 
  if (data.size() == 0) {
    throw std::runtime_error(
        util::io::Msg()
        << "Error: maxIndex() is called with data of size " << data.size()
        << ".\n");
  }
 
  if (data_end == 0 or data_end > data.size()) {
    throw std::runtime_error(
        util::io::Msg()
        << "Error: maxIndex() data_end = " << data_end
        << " is not valid for the data of size " << data.size()
        << ".\n");
  }
 
  if (data_start > data.size() - 1) {
    throw std::runtime_error(
        util::io::Msg()
        << "Error: maxIndex() data_start = " << data_start
        << " is not valid for the data of size " << data.size()
        << ".\n");
  }
 
  // initialize original index locations
  std::vector<size_t> idx(data_end - data_start);
  std::iota(idx.begin(), idx.end() , 0);
 
  std::stable_sort(idx.begin(), idx.end(),
                   [&data, &data_start](size_t i1, size_t i2)
                   {return data[i1 + data_start] > data[i2 + data_start];});
 
  return idx[0] + data_start;
};
 
inline size_t maxLengthIndex(const std::vector<util::Point> &data) {
      std::vector<double> length_data(data.size());
      for (size_t i = 0; i < data.size(); i++)
        length_data[i] = data[i].length();
 
      return util::methods::maxIndex(length_data);
};
 
inline size_t minLengthIndex(const std::vector<util::Point> &data) {
  std::vector<double> length_data(data.size());
  for (size_t i = 0; i < data.size(); i++)
    length_data[i] = data[i].length();
 
  return util::methods::minIndex(length_data);
};
 
inline double maxLength(const std::vector<util::Point> &data) {
      std::vector<double> length_data(data.size());
      for (size_t i = 0; i < data.size(); i++)
        length_data[i] = data[i].length();
 
      return length_data[util::methods::maxIndex(length_data)];
};
 
inline double minLength(const std::vector<util::Point> &data) {
      std::vector<double> length_data(data.size());
      for (size_t i = 0; i < data.size(); i++)
        length_data[i] = data[i].length();
 
      return length_data[util::methods::minIndex(length_data)];
};
 
inline std::pair<double, size_t> maxLengthAndMaxLengthIndex(const std::vector<util::Point> &data) {
      std::vector<double> length_data(data.size());
      for (size_t i = 0; i < data.size(); i++)
        length_data[i] = data[i].length();
 
      auto i = util::methods::maxIndex(length_data);
      return {length_data[i], i};
};
 
inline std::pair<double, size_t> minLengthAndMinLengthIndex(const std::vector<util::Point> &data) {
      std::vector<double> length_data(data.size());
      for (size_t i = 0; i < data.size(); i++)
        length_data[i] = data[i].length();
 
      auto i = util::methods::minIndex(length_data);
      return {length_data[i], i};
};
 
 
template <typename T>
inline T add(const std::vector<T> &data) {
  return std::reduce(data.begin(), data.end());
};
 
 
inline bool isFree(const int &i, const unsigned int &dof) {
      return !(i >> dof & 1UL);
};
 
inline bool isFree(const uint8_t &i, const unsigned int &dof) {
      return !(i >> dof & 1UL);
};
 
template <typename T>
inline bool isInList(const T &i, const std::vector<T> &list) {
      for (const auto &j : list)
        if (j == i)
          return true;
 
      return false;
};
 
inline bool isTagInList(const std::string &tag, const std::vector<std::string> &tags) {
  return isInList(tag, tags);
};
 
template <typename T>
inline void addToList(const T &i, std::vector<T> &list) {
  for (const auto &j : list)
    if (j == i)
      return;
 
  list.emplace_back(i);
};
 
inline float timeDiff(std::chrono::steady_clock::time_point begin,
                std::chrono::steady_clock::time_point end, std::string unit = "microseconds") {
      if (unit == "microseconds")
        return std::chrono::duration_cast<std::chrono::microseconds>(end - begin).count();
      else if (unit == "milliseconds")
        return std::chrono::duration_cast<std::chrono::milliseconds>(end - begin).count();
      else if (unit == "seconds")
        return std::chrono::duration_cast<std::chrono::seconds>(end - begin).count();
      else {
        throw std::runtime_error(
            util::io::Msg()
            << "Unit = " << unit << " not valid.\n");
      }
};
 
template <typename T_out>
inline T_out getKeyData(std::string key, std::map<std::string, T_out> &data_map, bool issue_err = false) {
 
  if (issue_err) {
    if (data_map.find(key) == data_map.end()) {
      throw std::runtime_error(
          util::io::Msg()
          << "Error: key = " << key << " does not exist in data map.\n");
    }
  }
 
  return data_map[key];
};
 
 
template <typename T_out>
inline void appendKeyData(std::string key, T_out data, std::map<std::string, T_out> &data_map, bool issue_err = false) {
 
  if (data_map.find(key) == data_map.end()) {
    if (issue_err) {
      throw std::runtime_error(
          util::io::Msg()
          << "Error: key = " << key << " does not exist in data map.\n");
    }
    else {
      data_map[key] = data;
    }
  }
  else {
    data_map[key] = data_map[key] + data;
  }
};
 
template <typename T_out>
inline void setKeyData(std::string key, T_out data, std::map<std::string, T_out> &data_map, bool issue_err = false) {
 
  if (data_map.find(key) == data_map.end()) {
    if (issue_err) {
      throw std::runtime_error(
          util::io::Msg()
          << "Error: key = " << key << " does not exist in data map.\n");
    }
  }
 
  data_map[key] = data;
};
 
template <class T>
inline T l2Dist(const std::vector<T> &x1, const std::vector<T> &x2) {
 
  if (x1.size() != x2.size())
    throw std::invalid_argument("size of two vectors not matching");
 
  T sum = 0.;
  for (size_t i=0; i<x1.size(); i++)
    sum += (x1[i] - x2[i]) * (x1[i] - x2[i]);
 
  return std::sqrt(sum);
}
 
} // namespace methods
 
} // namespace util