Functions.hpp

#pragma once
 
#include <Eigen/Dense>
#include <cmath>
#include <cstddef>
#include <filesystem>
#include <fstream>
#include <iostream>
#include <random>
 
namespace fs = std::filesystem;
 
namespace NeuralNet {
 
inline double mtRand(double min, double max) {
  assert(min < max);
  std::random_device rseed;
  std::mt19937_64 rng(rseed());
  std::uniform_real_distribution<double> dist(min, max);
 
  return dist(rng);
};
 
inline std::vector<double> randDVector(int size, double min = -10,
                                       double max = 10) {
  std::vector<double> v;
 
  for (int i = 0; i < size; i++) {
    v.push_back(mtRand(min, max));
  }
 
  return v;
}
 
inline bool fileExistsWithExtension(const std::string &filePath,
                                    const std::string &extension) {
  // Check if the file exist
  if (fs::exists(filePath)) {
    // Check if the file has specified extension
    fs::path file(filePath);
    return file.has_extension() && file.extension() == extension;
  }
 
  return false;
}
 
inline bool fileHasExtension(const std::string &filePath,
                             const std::string &extension) {
  fs::path file(filePath);
  return file.has_extension() && file.extension() == extension;
}
 
inline bool folderExists(const std::string &folderPath) {
  return fs::exists(folderPath) && fs::is_directory(folderPath);
}
 
inline std::string constructFilePath(const std::string &folderPath,
                                     const std::string &fileName) {
  std::string filepath;
 
// Running on windows
#ifdef _WIN32
  if (!folderPath.empty() && folderPath.back() != "\\")
    filepath = folderPath + "\\";
  else
    filepath = folderPath;
#else
  // Not running on Windows
  if (!folderPath.empty() && folderPath.back() != '/')
    filepath = folderPath + "/";
  else
    filepath = folderPath;
#endif
 
  return filepath + fileName;
};
 
/* MATHEMATICAL FUNCTIONS */
 
inline constexpr double sqr(const double x) { return x * x; };
 
/* VECTOR OPERATIONS */
 
template <typename T>
inline void reserve2d(std::vector<std::vector<T>> &v, int rows, int cols) {
  // reserve space for num rows
  v.reserve(rows);
 
  // reserve space for each row
  for (int i = 0; i < rows; i++) {
    v.push_back(std::vector<T>());
    v[i].reserve(cols);
  }
};
 
inline int findRowIndexOfMaxEl(const Eigen::MatrixXd &m) {
  // Find the maximum value in the matrix
  double maxVal = m.maxCoeff();
 
  // Find the row index by iterating through rows
  for (int i = 0; i < m.rows(); ++i) {
    if ((m.row(i).array() == maxVal).any()) {
      return i;
    }
  }
 
  // Return -1 if not found (this can be handled based on your use case)
  return -1;
};
 
template <typename T>
inline std::vector<T> flatten2DVector(const std::vector<std::vector<T>> &input,
                                      size_t rows, size_t cols) {
  // Asserting that the inputs respect the declared size
  assert(input.size() == rows);
  for (const std::vector<T> &row : input) {
    assert(row.size() == cols);
  }
 
  std::vector<T> result;
  result.reserve(rows * cols);
 
  // Flatten the 2D vector
  for (const std::vector<T> &row : input) {
    result.insert(result.end(), row.begin(), row.end());
  }
 
  return result;
}
 
template <typename T>
inline int findIndexOf(const std::vector<T> &v, const T &el) {
  auto it = std::find(v.begin(), v.end(), el);
 
  if (it == v.end()) return -1;
 
  return it - v.begin();
}
 
/* MATRIX OPERATIONS */
inline Eigen::MatrixXd zeroMatrix(const std::tuple<int, int> size) {
  return Eigen::MatrixXd::Zero(std::get<0>(size), std::get<1>(size));
}
 
inline Eigen::MatrixXd vectorToMatrixXd(std::vector<std::vector<double>> &v) {
  if (v.empty() || v[0].empty()) return Eigen::MatrixXd(0, 0);
 
  int rows = v.size();
  int cols = v[0].size();
 
  // Flatten the vector of vectors into a single vector
  std::vector<double> flat;
  flat.reserve(rows * cols);
  for (const auto &row : v) {
    flat.insert(flat.end(), row.begin(), row.end());
  }
 
  return Eigen::Map<
      Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>>(
      flat.data(), rows, cols);
};
 
static void randomWeightInit(Eigen::MatrixXd *weightsMatrix, double min = -1.0,
                             double max = 1.0) {
  for (int col = 0; col < weightsMatrix->cols(); col++) {
    for (int row = 0; row < weightsMatrix->rows(); row++) {
      weightsMatrix->operator()(row, col) = mtRand(min, max);
    }
  }
 
  return;
};
 
static void randomDistMatrixInit(Eigen::MatrixXd *weightsMatrix, double mean,
                                 double stddev) {
  std::random_device rseed;
  std::default_random_engine generator(rseed());
  std::normal_distribution<double> distribution(mean, stddev);
 
  for (int col = 0; col < weightsMatrix->cols(); col++) {
    for (int row = 0; row < weightsMatrix->rows(); row++) {
      weightsMatrix->operator()(row, col) = distribution(generator);
    }
  }
 
  return;
};
 
static Eigen::MatrixXd hardmax(const Eigen::MatrixXd &mat) {
  Eigen::MatrixXd hardmaxMatrix = Eigen::MatrixXd::Zero(mat.rows(), mat.cols());
 
  for (int i = 0; i < mat.rows(); ++i) {
    int maxIndex;
    mat.row(i).maxCoeff(&maxIndex);
 
    hardmaxMatrix(i, maxIndex) = 1;
  }
 
  return hardmaxMatrix;
}
 
static Eigen::MatrixXd trim(const Eigen::MatrixXd &logits,
                            double threshold = 0.01) {
  return (logits.array() < threshold).select(0, logits);
}
 
static Eigen::MatrixXd thresh(const Eigen::MatrixXd &logits,
                              double threshold = 0.01) {
  return (logits.array() < threshold).select(threshold, logits);
}
 
/* SIGNAL HANDLING */
static void signalHandler(int signum) {
  std::cout << "Interrupt signal (" << signum << ") received.\n";
 
  // cleanup and close up stuff here
  // terminate program
  exit(signum);
};
 
/* STRING OPERATIONS  */
 
static std::string removeTrailingZeros(std::string str) {
  str.erase(str.find_last_not_of('0') + 1, std::string::npos);
 
  if (str.back() == '.') {
    str.pop_back();
  }
 
  return str;
}
 
}  // namespace NeuralNet