StringUtils.h

Go to the documentation of this file.

 
#pragma once
 
#include <cmath>
#include <regex>
#include <set>
#include <string>
#include <vector>
 
#include "autopas/utils/NumberInterval.h"
#include "autopas/utils/NumberSet.h"
#include "autopas/utils/NumberSetFinite.h"
 
namespace autopas::utils::StringUtils {
 
// anonymous namespace for namespace-private helper functions
namespace {
inline int needlemanWunschScore(std::string s1, std::string s2) {
  // these scores correspond to the number of edits needed to match s1 to s2
  constexpr int scoreMatch = 1;
  constexpr int scoreMismatch = -1;
  constexpr int scoreGap = -1;
 
  // |s1|+1 x |s2|+1 Matrix
  std::vector<std::vector<int>> scoreMatrix(s1.length() + 1, std::vector<int>(s2.length() + 1, 0));
 
  // initialize top and right border with cumulative gap penalties
  for (size_t i = 0; i < scoreMatrix.size(); ++i) {
    scoreMatrix[i][0] = i * scoreGap;
  }
  for (size_t j = 0; j < scoreMatrix[0].size(); ++j) {
    scoreMatrix[0][j] = j * scoreGap;
  }
 
  // fill rest of matrix
  for (size_t i = 1; i < scoreMatrix.size(); ++i) {
    for (size_t j = 1; j < scoreMatrix[0].size(); ++j) {
      auto matchValue = s1[i - 1] == s2[j - 1] ? scoreMatch : scoreMismatch;
      auto scoreDiagonal = scoreMatrix[i - 1][j - 1] + matchValue;
      auto scoreLeft = scoreMatrix[i - 1][j] + scoreGap;
      auto scoreTop = scoreMatrix[i][j - 1] + scoreGap;
 
      std::array<decltype(scoreDiagonal), 3> scores = {scoreDiagonal, scoreLeft, scoreTop};
      auto scoreMax = std::max_element(scores.begin(), scores.end());
 
      scoreMatrix[i][j] = *scoreMax;
    }
  }
 
  // omit backtracking since we are not interested in the alignment but only in
  // the score lower right corner contains similarity score
  return scoreMatrix[scoreMatrix.size() - 1][scoreMatrix[scoreMatrix.size() - 1].size() - 1];
}
}  // namespace
inline std::string matchStrings(const std::vector<std::string> &haystack, std::string needle) {
  std::transform(needle.begin(), needle.end(), needle.begin(), ::tolower);
  auto bestDistance = std::numeric_limits<int>::min();
  std::vector<std::string> matchedStrings;
  for (auto &s : haystack) {
    auto distance = needlemanWunschScore(needle, s);
    // if we find a better match throw out current matches
    if (distance > bestDistance) {
      matchedStrings.clear();
      bestDistance = distance;
    }
    // save every match that is at least as good as the current one
    if (distance >= bestDistance) {
      matchedStrings.push_back(s);
    }
  }
  if (matchedStrings.size() > 1) {
    utils::ExceptionHandler::exception("Given String ({}) is ambiguous! Which option do you mean: {}", needle,
                                       [](auto arr) -> std::string {
                                         std::ostringstream ss;
                                         for (auto &a : arr) {
                                           ss << a << ", ";
                                         }
                                         // deletes last comma
                                         ss << "\b\b";
                                         return ss.str();
                                       }(matchedStrings));
  }
  return matchedStrings[0];
}
 
constexpr char delimiters[] = " ,;|/";
constexpr char delimitersRgx[] = "[\\s,;|/]";
constexpr char delimitersRgxInv[] = "[^\\s,;|/]";
 
static const std::string regexDoubleStr{
    "[0-9]+"  // at least one int
    "\\.?"    // maybe a dot
    "[0-9]*"  // maybe more integers after the dot
    "(?:"     // start of non-capturing group for exp
    "e"       // exponent
    "-?"      // optional minus
    "[0-9]+"  // at least one int
    ")?"      // end of group, group is optional
};
 
inline std::vector<std::string> tokenize(const std::string &searchString, const std::string &delimiters) {
  std::vector<std::string> wordVector;
 
  std::size_t prev = 0, pos;
  while ((pos = searchString.find_first_of(delimiters, prev)) != std::string::npos) {
    if (pos > prev) wordVector.push_back(searchString.substr(prev, pos - prev));
    prev = pos + 1;
  }
  if (prev < searchString.length()) wordVector.push_back(searchString.substr(prev, std::string::npos));
 
  return wordVector;
}
 
inline std::array<double, 3> parseArrayD3(const std::string &string) {
  std::array<double, 3> parsedArray{};
  auto strings = tokenize(string, delimiters);
  if (strings.size() > 3) {
    autopas::utils::ExceptionHandler::exception("parseArrayD3(): found {} instead of 3 array fields.", strings.size());
  }
  for (int i = 0; i < 3; i++) {
    try {
      parsedArray[i] = std::stod(strings[i]);
    } catch (const std::exception &e) {
      autopas::utils::ExceptionHandler::exception("parseArrayD3(): could not convert {} to a double: \n{}", strings[i],
                                                  e.what());
    }
  }
  return parsedArray;
}
 
inline bool parseBoolOption(const std::string &booleanOption) {
  if (booleanOption == "on" or booleanOption == "true" or booleanOption == "enabled") {
    return true;
  } else if (booleanOption == "off" or booleanOption == "false" or booleanOption == "disabled") {
    return false;
  } else {
    autopas::utils::ExceptionHandler::exception("Unknown boolean Option: {}", booleanOption);
  }
  // should not be reached
  return false;
}
 
inline std::set<double> parseDoubles(const std::string &doubleString) {
  std::set<double> doubles;
 
  std::regex regexDouble(regexDoubleStr);
 
  // use regex iter to find all doubles in the string.
  for (auto number = std::sregex_iterator(doubleString.begin(), doubleString.end(), regexDouble);
       number != std::sregex_iterator(); ++number) {
    try {
      double value = stod(number->str());
      doubles.insert(value);
    } catch (const std::exception &) {
      autopas::utils::ExceptionHandler::exception("Failed to parse a double from: {}", number->str());
    }
  }
 
  return doubles;
}
 
inline std::unique_ptr<autopas::NumberSet<double>> parseNumberSet(const std::string &setString) {
  // try to match an interval x-y
  std::regex regexInterval("("                 // start of 1. capture
                           + regexDoubleStr +  // a double
                           ")"                 // end of 1. capture
                           "\\s*"              // maybe whitespaces
                           "-"                 // a dash
                           "\\s*"              // maybe more whitespaces
                           "("                 // start of 2. capture
                           + regexDoubleStr +  // a double
                           ")"                 // end of 2. capture
  );
  std::smatch matches;
  if (std::regex_match(setString, matches, regexInterval)) {
    try {
      // matchers has whole string as str(0) so start at 1
      double min = stod(matches.str(1));
      double max = stod(matches.str(2));
      return std::make_unique<autopas::NumberInterval<double>>(min, max);
    } catch (const std::exception &) {
      // try parseDoubles instead
    }
  }
 
  std::set<double> values = autopas::utils::StringUtils::parseDoubles(setString);
  return std::make_unique<autopas::NumberSetFinite<double>>(values);
}
 
}  // namespace autopas::utils::StringUtils