vector_utilities.h

#pragma once
#include <vector>
#include <algorithm>
#include <limits>

namespace vecUtil
{

// Check if two vectors are equal.
template <typename T>
bool vector_eq(const std::vector<T> &a, const std::vector<T> &b)
{
    if (a.size() != b.size())
        return false;

    for (size_t i = 0; i < a.size(); i++)
    {
        if (a[i] != b[i])
            return false;
    }

    return true;
}

// Insert `vecToCopyFrom` data into `vecToInsert` at `insertAtPos`, copy from `copyFromPos` `copySize` number of elements.
template <typename T>
inline void vector_insert_at(std::vector<T> &vecToInsertInto, const std::vector<T> &vecToCopyFrom,
                             const size_t insertAtPos, const size_t copyFromPos, const size_t copySize)
{
    for (size_t i = 0; i < copySize; i++)
    {
        vecToInsertInto[insertAtPos + i] = vecToCopyFrom[copyFromPos + i];
    }
}

template <typename T>
inline T *last_element_pointer(std::vector<T> *vector)
{
    return (vector->empty() ? vector->data() : &vector->back());
}

template <typename T>
inline bool contains(const std::vector<T> &vec, const T &elem)
{
    return (std::find(vec.begin(), vec.end(), elem) != vec.end());
}

template <typename T, typename DiffType>
std::vector<DiffType> diff_vectors(const std::vector<T> &a, const std::vector<T> &b)
{
    always_assert(a.size() == b.size());

    std::vector<DiffType> result;
    result.resize(a.size());
    for (size_t i = 0; i < a.size(); i++)
    {
        result[i] = (DiffType)(b[i] - a[i]);
    }

    return result;
}

template <typename T>
T find_max(const std::vector<T> &data)
{
    T max = std::numeric_limits<T>::min();
    for (size_t i = 0; i < data.size(); i++)
    {
        if (data[i] > max)
        {
            max = data[i];
        }
    }
    return max;
}

template <typename T>
T find_min(const std::vector<T> &data)
{
    T min = std::numeric_limits<T>::max();
    for (size_t i = 0; i < data.size(); i++)
    {
        if (data[i] < min)
        {
            min = data[i];
        }
    }
    return min;
}

template <typename T>
std::pair<T, T> find_min_max(const std::vector<T> &data)
{
    T min = std::numeric_limits<T>::max();
    T max = std::numeric_limits<T>::min();

    for (size_t i = 0; i < data.size(); i++)
    {
        if (data[i] < min)
        {
            min = data[i];
        }

        if (data[i] > max)
        {
            max = data[i];
        }
    }
    return std::make_pair(min, max);
}

}; // namespace vecUtil