perm_mat.h

#pragma once
 
#include "mat.h"
#include "vec.h"
 
 
namespace cgv {
        namespace math {
struct perm_mat
{
        vec<unsigned> _data;
        
        perm_mat(){}
        
        explicit perm_mat(unsigned n)
        {
                resize(n);
                identity();
        }
 
        perm_mat(vec<unsigned> p)
        {
                _data = p;
        }
 
        unsigned size() const 
        {
                return _data.size();
        }
 
        unsigned nrows() const
        {
                return _data.size();
        }
 
        unsigned ncols() const
        {
                return _data.size();
        }
 
 
 
 
        void resize(unsigned n)
        {
                _data.resize(n);
                for(unsigned i = 0; i < n; i++)
                        _data[i] = i;
 
        }
 
        void transpose()
        {
                math::vec<unsigned> temp(_data.size());
                for(unsigned i = 0; i < _data.size(); i++)
                        temp[_data[i]] = i;
                _data=temp;
        }
 
        template <typename T>
        operator const mat<T>() const
        {
                mat<T> m;
                m.zeros(size(),size());
 
                for(unsigned i =0; i < size();i++)
                        m(i,_data[i])=(T)1.0;
                
                return m;
        }
 
        perm_mat operator*(const perm_mat& m)
        {
                assert(size() == m.size());
                perm_mat r(size());
                
                for(unsigned i = 0; i < size();i++)
                {
                        r(i) = m(operator()(i));
                }
                
                return r;
        }
 
        
 
 
        void identity()
        {
                for(unsigned i = 0; i < _data.size(); i++)
                        _data[i] = i;
        }
 
        //add permutation of the entries i and j
        void swap(unsigned i, unsigned j)
        {
                
                std::swap(_data[i],_data[j]);
        }
 
        unsigned& operator()(unsigned i) 
        {
                return _data[i];
        }
 
 
        unsigned& operator[](unsigned i) 
        {
                return _data[i];
        }
        
        
        unsigned operator()(unsigned i) const
        {
                return _data[i];
        }
 
 
        unsigned operator[](unsigned i) const
        {
                return _data[i];
        }
        
        
 
};
 
 
//multiplies a permutation matrix from left to apply a rows permutation
template<typename T>
mat<T> operator*(const perm_mat& p, const mat<T>& m)
{
        mat<T> r(m.nrows(),m.ncols());
 
        for(unsigned i = 0; i < m.nrows(); i++)
        {
                for(unsigned j = 0; j < m.ncols(); j++)
                        r(p(i),j)=m(i,j);
        }
        return r;
}
 
 
 
 
//multiplies a permutation matrix from right to perform a column permutation
template<typename T>
mat<T> operator*(const mat<T>& m, const perm_mat& p)
{
        mat<T> r(m.nrows(),m.ncols());
 
        for(unsigned i = 0; i < m.nrows(); i++)
        {
                for(unsigned j = 0; j < m.ncols(); j++)
                        r(i,p(j)) = m(i,j);
        }
        return r;
}
 
 
 
 
 
//multiplies a permutation matrix from left to perform an element permutation on vector v
template<typename T>
vec<T> operator*(const perm_mat& p, const vec<T>& v)
{
        vec<T> r(v.size());
        for(unsigned i = 0; i < v.size(); i++)
        {
        
                r(p[i]) = v(i);
                
        }
        return r;
}
 
 
inline perm_mat transpose(const perm_mat &p)
{
        perm_mat r=p;
        r.transpose();
        return r;
}
 
 
 
 
inline std::ostream& operator<<(std::ostream& out,const  perm_mat& m)
{
        
        for (int i=0;i<(int)m.size();++i)
                out << i << "->"<< m(i)<<"\n";
 
        return out;
}
 
 
 
 
}
 
}