comb.hpp

#ifndef COMB_HPP
#define COMB_HPP

#define COMB_ERROR 1001lu

#include "util/se_util.hpp"

template<unsigned int dim>
struct comb
{
    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&(char c_)
    {
        comb<dim> ret;

        for (size_t i = 0 ; i < dim ; i++)
        {
            ret.c[i] = c[i] & c_;
        }

        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 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 char operator[](int i) const
    {
        return c[i];
    }

    inline char * getComb()
    {
        return c;
    }

    inline const char * getComb() const
    {
        return c;
    }

    inline 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<char> c)
    {
        size_t i = 0;
        for(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>
{
    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 char operator[](int i)
    {
        return 0;
    }

    inline char * getComb()
    {
        return c;
    }

    inline 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