comb.hpp

#ifndef COMB_HPP
#define COMB_HPP
 
#define COMB_ERROR 1001lu
 
#include "util/se_util.hpp"
 
template<unsigned int dim>
struct comb
{
    signed char c[dim];
 
    inline bool isValid()
    {
        for (size_t i = 0 ; i < dim ; i++)
        {
            if (c[i] != 1 && c[i] != -1 && c[i] != 0)
            {
                return false;
            }
        }
 
        return true;
    }
 
    inline bool isSub(comb<dim> cmb)
    {
        for (size_t i = 0 ; i < dim ; i++)
        {
            if (c[i] != 0 && c[i] != cmb.c[i])
            {
                return false;
            }
        }
 
        return true;
    }
 
    inline void zero()
    {
        for (size_t i = 0 ; i < dim ; i++)
        {
            c[i] = 0;
        }
    }
 
    inline void mone()
    {
        for (size_t i = 0 ; i < dim ; i++)
        {
            c[i] = -1;
        }
    }
 
    inline comb<dim> operator&(signed char c_)
    {
        comb<dim> ret;
 
        for (size_t i = 0 ; i < dim ; i++)
        {
            ret.c[i] = c[i] & c_;
        }
 
        return ret;
    }
 
    inline void sign_flip()
    {
        for (size_t i = 0 ; i < dim ; i++)
        {
            c[i] = -c[i];
        }
    }
 
    inline comb<dim> operator-(const comb<dim> & t)
    {
        comb<dim> ret;
 
        for (size_t i = 0 ; i < dim ; i++)
        {
            ret.c[i] = c[i] - t.c[i];
        }
 
        return ret;
    }
 
    inline comb<dim> flip()
    {
        comb<dim> ret;
 
        for (size_t i = 0 ; i < dim ; i++)
        {
            ret.c[i] = -abs(c[i]);
        }
 
        return ret;
    }
 
    inline comb<dim> operator-()
    {
        comb<dim> ret;
 
        for (size_t i = 0 ; i < dim ; i++)
        {
            ret.c[i] = -c[i];
        }
 
        return ret;
    }
 
    inline comb<dim> operator+(const comb<dim> & t)
    {
        comb<dim> ret;
 
        for (size_t i = 0 ; i < dim ; i++)
        {
            ret.c[i] = c[i] + t.c[i];
        }
 
        return ret;
    }
 
    inline bool operator!=(const comb<dim> & t) const
    {
        // Check if the two combination match
 
        for (size_t i = 0 ; i < dim ; i++)
        {
            if (c[i] != t.c[i])
                return true;
        }
 
        // They match
 
        return false;
    }
 
    inline bool operator==(const comb<dim> & t) const
    {
        return !this->operator!=(t);
    }
 
    inline signed char operator[](int i) const
    {
        return c[i];
    }
 
    inline signed char * getComb()
    {
        return c;
    }
 
    inline const signed char * getComb() const
    {
        return c;
    }
 
    inline signed char value(int i) const
    {
        return c[i];
    }
 
 
    /* \brief It return the number of zero in the combination
     *
     * \return number of zero
     *
     */
    inline int n_zero() const
    {
        int zero = 0;
 
        for (size_t i = 0 ; i < dim ; i++)
        {
            if (c[i] == 0) zero++;
        }
 
        return zero;
    }
 
    comb()
    {}
 
    comb(std::initializer_list<signed char> c)
    {
        size_t i = 0;
        for(signed char x : c)
        {this->c[c.size() - i - 1] = x;i++;}
    }
 
    bool isNegative()
    {
        for (size_t i = 0; i < dim ; i++)
        {
            if (c[i] > 0)
                return false;
        }
 
        return true;
    }
 
    std::string to_string() const
    {
        size_t i;
 
        std::stringstream str;
        str << "(";
 
        // convert to string
        for (i = 0 ; i < dim - 1 ; i++)
            str << std::to_string(c[i]) << ",";
 
        str << std::to_string(c[i]) << ")";
 
        return str.str();
    }
 
    size_t inline lin() const
    {
        size_t ret = 0;
        size_t accu = 1;
 
        for (size_t i = 0 ; i < dim ; i++)
        {
            ret += (c[i] + 1) * accu;
            accu *= 3;
        }
 
        return ret;
    }
};
 
template<>
struct comb<0>
{
    signed char c[0];
 
    inline bool isValid()
    {
        return true;
    }
 
    inline bool isSub(comb<0> cmb)
    {
        return true;
    }
 
    inline void zero()
    {
    }
 
 
    inline bool operator!=(const comb<0> & t) const
    {
        // They match
 
        return true;
    }
 
    inline bool operator==(const comb<0> & t) const
    {
        return true;
    }
 
    inline signed char operator[](int i)
    {
        return 0;
    }
 
    inline signed char * getComb()
    {
        return c;
    }
 
    inline signed char value(int i) const
    {
        return c[i];
    }
 
 
    /* \brief It return the number of zero in the combination
     *
     * \return number of zero
     *
     */
    inline int n_zero()
    {
        return 0;
    }
 
    /* \brief produce an unique number from the combination
     *
     *
     *
     */
    inline size_t lin()
    {
        return 0;
    }
};
 
// create a specialization of std::vector<comb<0>>
 
namespace std
{
    template<>
    class vector<comb<0>>
    {
        comb<0> * ptr;
 
    public:
 
        size_t size()
        {
            return 0;
        }
 
        comb<0> & operator[](size_t i)
        {
            return ptr[i];
        }
 
        void push_back(comb<0> & obj)
        {
        }
    };
}
 
#endif