utils.h

Go to the documentation of this file.

 
#ifndef UTILS_H
#define UTILS_H
 
#include <iostream>
#include <iomanip> // Required for setprecision and fixed
#include <locale> // Required for using thousands_separator
#include <sstream> // Required for stringstream
#include "vector.h"
#include <fstream>
#include <string>
#include <regex>
#include <chrono>
#include <cmath>
#include <tuple>
#include <type_traits>
#include <QVector>
#include <type_traits>
 
namespace Utils {
 
    using namespace std;
 
 
    inline std::pair<double, double> dot(Vector<Vector<double>> matrix, std::pair<double, double>& v) {
        // The dot product of a matrix and a vector is calculated as follows:
        // The first element is the sum of the products of the corresponding elements of the first row of the matrix and the vector
        // The second element is the sum of the products of the corresponding elements of the second row of the matrix and the vector
        return std::make_pair(matrix.at(0).at(0) * v.first + matrix.at(0).at(1) * v.second,
                              matrix.at(1).at(0) * v.first + matrix.at(1).at(1) * v.second);
    }
 
    inline double dot(std::pair<double, double> &u, std::pair<double, double> &v) {
        // The dot product of two vectors is calculated as (u1*v1 + u2*v2)
        return u.first * v.first + u.second * v.second;
    }
 
    inline double cross(std::pair<double, double> &u, std::pair<double, double> &v) {
        // The cross product of two vectors in 2D (also known as the determinant, or pseudo cross product)
        // is calculated as (u1*v2 - u2*v1)
        return u.first * v.second - u.second * v.first;
    }
 
    inline double getDistanceByTwoCoordinates(const std::pair<double, double>& position1,
                                       const std::pair<double, double>& position2) {
        // Calculate differences in x and y coordinates
        double xDiff = position1.first - position2.first;
        double yDiff = position1.second - position2.second;
 
        // Compute and return Euclidean distance
        return std::sqrt(xDiff * xDiff + yDiff * yDiff);
    }
 
    inline double power(double base, int exponent) {
        if (exponent == 0) {
            return 1.0;
        }
        else if (exponent < 0) {
            return 1.0 / power(base, -exponent);
        }
        else if (exponent % 2 == 0) {
            double temp = power(base, exponent / 2);
            return temp * temp;
        }
        else {
            return base * power(base, exponent - 1);
        }
    }
 
 
    template<typename T>
        requires std::is_arithmetic<T>::value
    inline std::string thousandSeparator(T n, int decimals = 3) {
        // Get the sign of the number and remove it
        int sign = (n < 0) ? -1 : 1;
        double approx = power((double)10.0, decimals);
        n *= sign;
        // Get the integer part of the number
        long long intPart = (long long)n;
        // Check if the fractional part has any value
        bool hasFracPart = (n - intPart > 0);
        // Get the fractional part of the number and trim it to n decimal places
        double fracPart = round((n - intPart) * (approx)) / (approx);
        // Create a locale object to represent a specific localization
        locale loc("");
        // Set the thousand separator according to the localization
        char separator = use_facet< numpunct<char> >(loc).thousands_sep();
        // Convert the integer part to a string
        string intStr = to_string(intPart);
        // Insert the separator every 3 digits from the end
        for (int i = intStr.length() - 3; i > 0; i -= 3) {
            intStr.insert(i, 1, separator);
        }
        // Convert the fractional part to a string and trim it to n decimal places
        stringstream stream;
        if (hasFracPart) {
            stream << fixed << setprecision(decimals) << fracPart;
        }
        string fracStr = (hasFracPart) ? stream.str().substr(1) : "";
        // Combine the integer and fractional parts into a single string
        string result = intStr + fracStr;
        // Add the sign to the beginning of the string if the number was negative
        if (sign == -1) {
            result = "-" + result;
        }
        return result;
    }
 
 
    template<typename T>
 
    inline std::string formatDuration(T seconds) {
        int minutes = static_cast<int>(seconds) / 60;
        int hours = minutes / 60;
        int days = hours / 24;
        int remainingSeconds = static_cast<int>(seconds) % 60;
        int remainingMinutes = minutes % 60;
        int remainingHours = hours % 24;
        // Use stringstream to convert integer values to strings
        std::stringstream ss;
        ss << days << ":" << setw(2) << setfill('0') << remainingHours << ":" << setw(2) << setfill('0') << remainingMinutes << ":" << setw(2) << setfill('0') << remainingSeconds;
        std::string result = ss.str();
        return result;
    }
 
    inline std::string getFilenameWithoutExtension(std::string path) {
        size_t pos = path.find_last_of("/\\");
        string filename = (pos == string::npos) ? path : path.substr(pos + 1);
        size_t dotPos = filename.find_last_of(".");
        if (dotPos != string::npos) {
            filename = filename.substr(0, dotPos);
        }
        return filename;
    }
 
    inline std::string getPrefix(std::string str) {
        std::string prefix;
        bool skipFirstChar = isupper(str[0]);
        if (skipFirstChar) {
            prefix += str[0];
        }
        for (size_t i = skipFirstChar ? 1 : 0; i < str.length(); i++) {
            char c = str[i];
            if (c == '_' || isalpha(c) || c == ' ') {
                if (isupper(c) || c == ' ' || c == '_') {
                    break;
                }
                prefix += c;
            }
        }
        return prefix;
    }
 
 
    inline Vector<double> splitStringToDoubleVector(const std::string& input, char delimiter = ',') {
        Vector<double> result;
        std::stringstream ss(input);
        std::string item;
        while (std::getline(ss, item, delimiter)) {
            result.push_back(std::stod(item));
        }
        return result;
    }
 
    inline Vector<int> splitStringToIntVector(const std::string& str) {
        Vector<int> intVector;
        std::stringstream ss(str);
        int temp;
 
        while (ss >> temp) {
            intVector.push_back(temp);
            if (ss.peek() == ',') {
                ss.ignore();
            }
            else if (ss.peek() != ' ') {
                break;
            }
        }
 
        return intVector;
    }
 
    inline Vector<std::string> split(const std::string& s, char delimiter)
    {
        Vector<std::string> tokens;
        std::string token;
        std::istringstream tokenStream(s);
        while (std::getline(tokenStream, token, delimiter))
        {
            tokens.push_back(token);
        }
        return tokens;
    }
 
    inline Vector<int> convertStringVectorToIntVector(const std::vector<std::string>& stringVector) {
        Vector<int> intVector;
 
        for(const auto& str : stringVector) {
            try {
                intVector.push_back(std::stoi(str));
            } catch(const std::exception& e) {
                throw std::runtime_error("Error: unable to convert string " + str + " to integer.");
            }
        }
 
        return intVector;
    }
 
    inline std::string trim(const std::string& str)
    {
        std::string s = str;
        s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](int ch) {
            return !std::isspace(ch);
            }));
        s.erase(std::find_if(s.rbegin(), s.rend(), [](int ch) {
            return !std::isspace(ch);
            }).base(), s.end());
        return s;
    }
 
    inline bool writeToFile(std::stringstream &s, std::string filename) {
        std::ofstream outputFile(filename);
        if (outputFile.is_open()) {
            outputFile << s.rdbuf();  // Write stringstream contents to file
            outputFile.close();
            return true;
        } else {
            return false;
        }
    }
 
    template <typename... Args>
    inline std::stringstream convertTupleToStringStream(const std::tuple<Args...>& t, int limit, std::string delim = "\t");
 
    template <typename Tuple, size_t... Indices>
    inline void addTupleValuesToStreamImpl(const Tuple& t, std::stringstream& ss,
                                           std::index_sequence<Indices...>, int limit, std::string delim);
 
    template <typename T>
    inline void writeToStream(const T& value, std::stringstream& ss, std::string delim);
 
 
 
    template <typename... Args>
    inline std::stringstream convertTupleToStringStream(const std::tuple<Args...>& t, int limit, std::string delim) {
        std::stringstream ss;
        addTupleValuesToStreamImpl(t, ss, std::index_sequence_for<Args...>(),
                                   limit > 0 ? limit: std::tuple_size<std::tuple<Args...>>::value - std::abs(limit) -1, delim);
        return ss;
    }
 
    template <typename Tuple, size_t... Indices>
    inline void addTupleValuesToStreamImpl(const Tuple& t,
                                           std::stringstream& ss,
                                           std::index_sequence<Indices...>,
                                           int limit, std::string delim) {
        ((Indices < limit
              ? Utils::writeToStream(std::get<Indices>(t), ss, delim) :
              void()), ...);
        ((Indices == limit
              ? Utils::writeToStream(std::get<Indices>(t), ss, "") :
              void()), ...);
    }
 
    template <typename T>
    inline void writeToStream(const T& value,
                              std::stringstream& ss,
                              std::string delim) {
        if constexpr (std::is_same_v<T, bool>) {
            ss << (value ? "1" : "0") << delim;
        } else {
            ss << value << delim;
        }
    }
 
    inline std::string removeLastWord(const std::string& originalString) {
 
        size_t lastSpaceIndex = originalString.find_last_of(' ');
 
        if (lastSpaceIndex != std::string::npos) {
            std::string updatedString = originalString.substr(0, lastSpaceIndex);
            return updatedString;
        } else {
            // Return the original string if there is no space
            return originalString;
        }
    }
 
    inline QVector<double> convertQStringVectorToDouble(const QVector<QString>& stringVector) {
        QVector<double> doubleVector;
        doubleVector.reserve(stringVector.size());
 
        for (const QString& str : stringVector) {
            bool ok;
            double value = str.toDouble(&ok);
            if (ok) {
                doubleVector.append(value);
            } else {
                // Handle conversion error if necessary
            }
        }
 
        return doubleVector;
    }
 
    inline QVector<double> subtractQVector(const QVector<double> l1, const QVector<double> l2) {
        QVector<double> result;
        if (l1.size() != l2.size()) {return result; }
 
        for (int i = 0; i < l1.size(); i++ ) {
            result.push_back(l1[i] - l2[i]);
        }
        return result;
    }
 
    inline QVector<double> factorQVector(const QVector<double> l1, const double factor) {
        QVector<double> result;
        if (l1.size() < 1) {return result; }
 
        for (int i = 0; i < l1.size(); i++ ) {
            result.push_back(l1[i] * factor);
        }
        return result;
    }
 
    inline Vector<std::pair<std::string, std::string>> splitStringStream(std::stringstream& ss, const std::string& delimiter = ":") {
        Vector<std::pair<std::string, std::string>> result;
        std::string line;
 
        while (std::getline(ss, line)) {
            std::size_t delimiterPos = line.find(delimiter);
            if (delimiterPos != std::string::npos) {
                std::string first = line.substr(0, delimiterPos);
                std::string second = line.substr(delimiterPos + delimiter.size());
                result.emplace_back(first, second);
            } else {
                result.emplace_back(line, "");  // If delimiter is not found, add the entire line with an empty second part
            }
        }
 
        return result;
    }
 
    inline std::string replaceAll(std::string str, const std::string& from, const std::string& to) {
        size_t start_pos = 0;
        while((start_pos = str.find(from, start_pos)) != std::string::npos) {
            str.replace(start_pos, from.length(), to);
            start_pos += to.length(); // Handles case where 'to' is a substring of 'from'
        }
        return str;
    }
 
 
}
 
 
#endif  // !UTILS_H