set.h

Go to the documentation of this file.

 
#include <algorithm>
#include <vector>
#pragma once
namespace set {
 
    template <typename T> inline bool contains(const std::vector<T>& k, const T& kk) noexcept; //Set contains
 
    template <typename T> inline int count(const std::vector<T>& k, const T& kk) noexcept; //Set count
 
    template <typename T> inline std::vector<T>& unique(std::vector<T>& c, const std::vector<T>& k); //Set unique
 
    template <typename T> inline std::vector<T>& unique(std::vector<T>& k); //Set overloaded unique
 
    template <typename T> inline std::vector<T> unique(std::vector<T>&& k); //Set overloaded rvalue unique
 
    template <typename T> inline std::vector<T>& sort(std::vector<T>& c, const std::vector<T>& k); //Set sort
 
    template <typename T> inline std::vector<T>& sort(std::vector<T>& k); //Set overloaded sort
 
    template <typename T> inline std::vector<T> sort(std::vector<T>&& k); //Set overloaded rvalue sort
 
    template <typename T> inline std::vector<T>& rsort(std::vector<T>& c, const std::vector<T>& k); //Set reverse sort
 
    template <typename T> inline std::vector<T>& rsort(std::vector<T>& k); //Set overloaded reverse sort
 
    template <typename T> inline std::vector<T> rsort(std::vector<T>&& k); //Set overloaded rvalue reverse sort
 
    template <typename T> inline std::vector<T>& reverse(std::vector<T>& c, const std::vector<T>& k); //Set reverse
 
    template <typename T> inline std::vector<T>& reverse(std::vector<T>& k); //Set overloaded reverse
 
    template <typename T> inline std::vector<T> reverse(std::vector<T>&& k); //Set overloaded rvalue reverse
    
    template <typename T> inline std::vector<T>& sunion(std::vector<T>& c, const std::vector<T>& k, const std::vector<T>& kk); //Set theory: Union
 
    template <typename T> inline std::vector<T> sunion(const std::vector<T>& k, const std::vector<T>& kk); //Set theory: Overloaded Union
 
    template <typename T> inline std::vector<T> sunion(std::vector<T>&& k, const std::vector<T>&& kk); //Set theory: Overloaded Rvalue Union
 
    template <typename T> inline std::vector<T>& intersection(std::vector<T>& c, const std::vector<T>& k, const std::vector<T>& kk); //Set theory: Intersection
 
    template <typename T> inline std::vector<T> intersection(const std::vector<T>& k, const std::vector<T>& kk); //Set theory: Overloaded Intersection
 
    template <typename T> inline std::vector<T> intersection(std::vector<T>&& k, const std::vector<T>&& kk); //Set theory: Overloaded Rvalue Intersection
 
    template <typename T> inline std::vector<T>& diff(std::vector<T>& c, const std::vector<T>& k, const std::vector<T>& kk); //Set theory: Difference
 
    template <typename T> inline std::vector<T> diff(const std::vector<T>& k, const std::vector<T>& kk); //Set theory: Overloaded Difference
 
    template <typename T> inline std::vector<T> diff(std::vector<T>&& k, const std::vector<T>&& kk); //Set theory: Overloaded Rvalue Difference
 
    template <typename T> inline std::vector<T>& sdiff(std::vector<T>& c, const std::vector<T>& k, const std::vector<T>& kk); //Set theory: Symmetric difference
 
    template <typename T> inline std::vector<T> sdiff(const std::vector<T>& k, const std::vector<T>& kk); //Set theory: Overloaded Symmetric difference
 
    template <typename T> inline std::vector<T> sdiff(std::vector<T>&& k, const std::vector<T>&& kk); //Set theory: Overloaded Rvalue Symmetric difference
}
 
//Set contains
template <typename T>
inline bool set::contains(const std::vector<T>& k, const T& kk) noexcept {
    for (const T& v: k) {if(v == kk) {return true;}}
    return false;
};
 
//Set count
template <typename T>
inline int set::count(const std::vector<T>& k, const T& kk) noexcept {
    int c = 0;
    for (const T& v: k) {if(v == kk) {c++;}}
    return c;
};
 
//Set unique
template <typename T>
inline std::vector<T>& set::unique(std::vector<T>& c, const std::vector<T>& k) {
    for (const T& v: k) {if(!set::contains(c, v)) {c.push_back(v);}}
    return c;
};
 
//Set overloaded unique
template <typename T>
inline std::vector<T>& set::unique(std::vector<T>& k) {
    std::vector<T> t;
    set::unique(t, k);
    k = std::move(t);
    return k;
};
 
//Set overloaded rvalue unique
template <typename T>
inline std::vector<T> set::unique(std::vector<T>&& k) {
    std::vector<T> t;
    set::unique(t, k);
    return t;
};
 
//Set sort
template <typename T>
inline std::vector<T>& set::sort(std::vector<T>& c, const std::vector<T>& k) {
    c = k;
    std::sort(c.begin(), c.end());
    return c;
}
 
//Set overloaded sort
template <typename T>
inline std::vector<T>& set::sort(std::vector<T>& k) {
    std::sort(k.begin(), k.end());
    return k;
}
 
//Set overloaded rvalue sort
template <typename T>
inline std::vector<T> set::sort(std::vector<T>&& k) {
    std::sort(k.begin(), k.end());
    return k;
}
 
//Set reverse sort
template <typename T>
inline std::vector<T>& set::rsort(std::vector<T>& c, const std::vector<T>& k) {
    c = k;
    std::sort(c.begin(), c.end(), std::greater<T>());
    return c;
}
 
//Set overloaded reverse sort
template <typename T>
inline std::vector<T>& set::rsort(std::vector<T>& k) {
    std::sort(k.begin(), k.end(), std::greater<T>());
    return k;
}
 
//Set overloaded rvalue everse sort
template <typename T>
inline std::vector<T> set::rsort(std::vector<T>&& k) {
    std::sort(k.begin(), k.end(), std::greater<T>());
    return k;
}
 
//Set reverse
template <typename T>
inline std::vector<T>& set::reverse(std::vector<T>& c, const std::vector<T>& k) {
    c = k;
    for (unsigned int i = 0; i < (k.size() / 2); i++) {std::swap(c[i], c[c.size() - i - 1]);}
    return c;
};
 
//Set overloaded reverse
template <typename T>
inline std::vector<T>& set::reverse(std::vector<T>& k) {
    for (unsigned int i = 0; i < (k.size() / 2); i++) {std::swap(k[i], k[k.size() - i - 1]);}
    return k;
};
 
//Set overloaded rvalue reverse
template <typename T>
inline std::vector<T> set::reverse(std::vector<T>&& k) {
    for (unsigned int i = 0; i < (k.size() / 2); i++) {std::swap(k[i], k[k.size() - i - 1]);}
    return k;
};
 
//Set theory: Union
template <typename T>
inline std::vector<T>& set::sunion(std::vector<T>& c, const std::vector<T>& k, const std::vector<T>& kk) {
    for (const T& v: k) {if(!set::contains(c, v)) {c.push_back(v);}}
    for (const T& vv: kk) {if(!set::contains(c, vv)) {c.push_back(vv);}}
    return c;
};
 
//Set theory: Overloaded Union
template <typename T>
inline std::vector<T> set::sunion(const std::vector<T>& k, const std::vector<T>& kk) {
    std::vector<T> r;
    set::sunion(r, k, kk);
    return r;
};
 
//Set theory: Overloaded Rvalue Union
template <typename T>
inline std::vector<T> set::sunion(std::vector<T>&& k, std::vector<T>&& kk) {
    std::vector<T> r;
    set::sunion(r, k, kk);
    return r;
};
 
//Set theory: Intersection
template <typename T>
inline std::vector<T>& set::intersection(std::vector<T>& c, const std::vector<T>& k, const std::vector<T>& kk) {
    for (const T& v: k) {if((!set::contains(c, v)) && (set::contains(kk, v))) {c.push_back(v);}}
    for (const T& vv: kk) {if((!set::contains(c, vv)) && (set::contains(k, vv))) {c.push_back(vv);}}
    return c;
};
 
//Set theory: Overloaded Intersection
template <typename T>
inline std::vector<T> set::intersection(const std::vector<T>& k, const std::vector<T>& kk) {
    std::vector<T> r;
    set::intersection(r, k, kk);
    return r;
};
 
//Set theory: Overloaded Rvalue Intersection
template <typename T>
inline std::vector<T> set::intersection(std::vector<T>&& k, std::vector<T>&& kk) {
    std::vector<T> r;
    set::intersection(r, k, kk);
    return r;
};
 
//Set theory: Difference
template <typename T>
inline std::vector<T>& set::diff(std::vector<T>& c, const std::vector<T>& k, const std::vector<T>& kk) {
    for (const T& v: k) {if(!contains(kk, v)) {c.push_back(v);}}
    return c;
};
 
//Set theory: Overloaded Difference
template <typename T>
inline std::vector<T> set::diff(const std::vector<T>& k, const std::vector<T>& kk) {
    std::vector<T> r;
    set::diff(r, k, kk);
    return r;
};
 
//Set theory: Overloaded Rvalue Difference
template <typename T>
inline std::vector<T> set::diff(std::vector<T>&& k, std::vector<T>&& kk) {
    std::vector<T> r;
    set::diff(r, k, kk);
    return r;
};
 
//Set theory: Symmetric difference
template <typename T>
inline std::vector<T>& set::sdiff(std::vector<T>& c, const std::vector<T>& k, const std::vector<T>& kk) {
    set::diff(c, k, kk);
    set::diff(c, kk, k);
    return c;
};
 
//Set theory: Overloaded Symmetric difference
template <typename T>
inline std::vector<T> set::sdiff(const std::vector<T>& k, const std::vector<T>& kk) {
    std::vector<T> r;
    set::sdiff(r, k, kk);
    return r;
};
 
//Set theory: Overloaded Rvalue Symmetric difference
template <typename T>
inline std::vector<T> set::sdiff(std::vector<T>&& k, std::vector<T>&& kk) {
    std::vector<T> r;
    set::sdiff(r, k, kk);
    return r;
};