Utilities.h

Go to the documentation of this file.

#pragma once
 
#include <map>
#include <vector>
#include <unordered_map>
#include <algorithm>
#include <numeric>        
#include <iostream>
#include <fstream>
 
#include <TVectorD.h>
 
using std::cerr;
using std::endl;
 
 
namespace Utilities
{
    //________________________________________________________________________________________________________
    bool does_file_exist(const char *fileName)
    {
        
        return static_cast<bool>(std::ifstream(fileName));
    }
 
 
    //________________________________________________________________________________________________________
    int CalculatePairs(int n)
    {
        int value = n * (n - 1) / 2;
        return value > 0 ? value : 0;
    }
}
 
 
 
 
namespace VectorUtilities
{
    //________________________________________________________________________________________________________
    double sumVector(const std::vector<double> &v)
    {
        //return accumulate(v.begin(), v.end(), decltype(v)::value_type(0));
        return std::accumulate(v.begin(), v.end(), 0.0);
    }
 
 
    //________________________________________________________________________________________________________
    template <typename T>
    void printVector(const std::vector<T> &v) 
    {
        for (const T &x : v)
            std::cout << x << ", ";
        std::cout << std::endl;
    }
 
 
    //________________________________________________________________________________________________________
    void printVectorOfVectors(std::vector<std::vector<double>> const &mat) 
    {
        for (const std::vector<double> &v : mat)
        {
           for (double x : v)
               std::cout << x <<' ';
           std::cout<<std::endl;
        }
    }
 
 
    //________________________________________________________________________________________________________
    std::map<int, int> GetUniqueElementsAndFrequency(const std::vector<int>& vec)
    {
        std::map<int, int> frequencyMap;
 
        for(const int &val : vec)
        {
            frequencyMap[val]++;
        }
 
        return frequencyMap;
    }
 
 
    //________________________________________________________________________________________________________
    void filterAndShrinkMap(std::map<int, int>& frequencyMap, int threshold = 2)
    {
        for (auto it = frequencyMap.begin(); it != frequencyMap.end();) {
            if (it->second < threshold)
                it = frequencyMap.erase(it);
            else
                ++it;
        }
        
        std::map<int, int>(frequencyMap).swap(frequencyMap);
    }
 
 
    //________________________________________________________________________________________________________
    template <typename T>
    bool areAllElementsEqual(const std::vector<T>& vec)
    {
        if (vec.size() == 0)
            std::cerr << "\n\nWARNING: Empty Vector! Size is Zero (0).\n\n";
        return std::adjacent_find(vec.begin(), vec.end(), [](const T& a, const T& b) { return a != b; }) == vec.end();
    }
 
 
    //________________________________________________________________________________________________________
    int getMajorityElement(const std::vector<int>& vec)
    {
        std::unordered_map<int, int> freq;
 
        for (int num : vec) {
            freq[num]++;
        }
 
        int majorityElement = vec[0];
        int maxCount = 0;
        for (const auto& pair : freq) {
            if (pair.second > maxCount) {
                maxCount = pair.second;
                majorityElement = pair.first;
            }
        }
 
        return majorityElement;
    }
 
 
    //________________________________________________________________________________________________________
    int countDifferentFromMajority(const std::vector<int>& vec) 
    {
        // Obtain the majority element by calling getMajorityElement
        int majorityElement = getMajorityElement(vec);
 
        // Count the number of elements that are different from the majority element
        int count = 0;
        for (int num : vec) {
            if (num != majorityElement) {
                count++;
            }
        }
 
        return count;
    }
    
    
    //________________________________________________________________________________________________________
    std::vector<double> TVectorDToStdVector(const TVectorD &vec)
    {
        std::vector<double> stdVec(vec.GetNrows());
        for (int i = 0; i < vec.GetNrows(); ++i) {
            stdVec[i] = vec(i);
        }
        return stdVec;
    }
    
    
    //________________________________________________________________________________________________________
    bool AreVectorsEqual(const std::vector<double>& vec1,
                         const std::vector<double>& vec2,
                         double tol = 1e-4)
    {
        if (vec1.size() != vec2.size())
            return false;
 
        for (size_t i = 0; i < vec1.size(); ++i)
        {
            if (std::abs(vec1[i] - vec2[i]) > tol)
                return false;
        }
 
        return true;
    }
}