/*
    LA: linear algebra C++ interface library
    Copyright (C) 2021 Jiri Pittner <jiri.pittner@jh-inst.cas.cz> or <jiri@pittnerovi.com>

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "vec.h"
#include "permutation.h"
#include "miscfunc.h"
#include <stdio.h>
#include <string.h>
#include <list>
#include "qsort.h"
#include "bitvector.h"


namespace LA {

template <typename T>
void NRPerm<T>::identity()
{
T n=this->size();
#ifdef DEBUG
        if(n<0) laerror("invalid permutation size");
#endif
if(n==0) return;
this->copyonwrite();
for(T i=1; i<=n; ++i) (*this)[i]=i;
}


template <typename T>
bool NRPerm<T>::is_identity() const
{
T n=this->size();
#ifdef DEBUG
        if(n<0) laerror("invalid permutation size");
#endif
if(n==0) return 1;
for(T i=1; i<=n; ++i) if((*this)[i]!=i) return 0;
return 1;
}



template <typename T>
bool NRPerm<T>::is_valid() const
{
T n = this->size();
if(n<0) return 0;
NRVec_from1<T> used(n);
used.clear();
for(T i=1; i<=n; ++i)
	{
	T x= (*this)[i];
	if(x<1||x>n) return 0;
	used[x] += 1;
	}
for(T i=1; i<=n; ++i) if(used[i]!=1) return 0;
return 1;
}

template <typename T>
NRPerm<T> NRPerm<T>::inverse() const
{
#ifdef DEBUG
	if(!this->is_valid()) laerror("inverse of invalid permutation");
#endif

NRPerm<T> q(this->size());
for(T i=1; i<=this->size(); ++i) q[(*this)[i]]=i;
return q;
}

template <typename T>
NRPerm<T> NRPerm<T>::reverse() const
{
#ifdef DEBUG
        if(!this->is_valid()) laerror("reverse of invalid permutation");
#endif

NRPerm<T> q(this->size());
for(T i=1; i<=this->size(); ++i) q[i]=(*this)[this->size()-i+1];
return q;
}

template <typename T>
NRPerm<T> NRPerm<T>::operator&(const NRPerm<T> &q) const
{
#ifdef DEBUG
        if(!this->is_valid() || !q.is_valid()) laerror("concatenation of invalid permutation");
#endif

NRPerm<T> r(size()+q.size());
for(int i=1; i<=size(); ++i) r[i]=(*this)[i];
for(int i=1; i<=q.size(); ++i) r[size()+i]=size()+q[i];
return r;
}

template <typename T>
NRPerm<T> NRPerm<T>::operator|(const NRPerm<T> &q) const
{
#ifdef DEBUG
        if(!this->is_valid() || !q.is_valid()) laerror("concatenation of invalid permutation");
#endif

NRPerm<T> r(size()+q.size());
for(int i=1; i<=q.size(); ++i) r[i]=size()+q[i];
for(int i=1; i<=size(); ++i) r[q.size()+i]=(*this)[i];
return r;
}



template <typename T>
NRPerm<T> NRPerm<T>::operator*(const NRPerm<T> &q) const
{
#ifdef DEBUG
        if(!this->is_valid() || !q.is_valid()) laerror("multiplication of invalid permutation");
#endif

T n=this->size();
if(n!=q.size()) laerror("product of incompatible permutations");
NRPerm<T> r(n);
for(T i=1; i<=n; ++i) r[i] = (*this)[q[i]];
return r;
}

template <typename T>
NRPerm<T> NRPerm<T>::multiply(const NRPerm<T> &q, bool inverse) const
{
#ifdef DEBUG
        if(!this->is_valid() || !q.is_valid()) laerror("multiplication of invalid permutation");
#endif

T n=this->size();
if(n!=q.size()) laerror("product of incompatible permutations");
NRPerm<T> r(n);
if(inverse) for(T i=1; i<=n; ++i) r[q[i]] = (*this)[i];
else for(T i=1; i<=n; ++i) r[i] = (*this)[q[i]];
return r;
}



template <typename T>
NRPerm<T> NRPerm<T>::conjugate_by(const NRPerm<T> &q, bool inverse) const
{
#ifdef DEBUG
        if(!this->is_valid() || !q.is_valid()) laerror("multiplication of invalid permutation");
#endif

T n=this->size();
if(n!=q.size()) laerror("product of incompatible permutations");
NRPerm<T> qi=q.inverse();
NRPerm<T> r(n);
if(inverse)  for(T i=1; i<=n; ++i) r[i] = q[(*this)[qi[i]]];
else for(T i=1; i<=n; ++i) r[i] = qi[(*this)[q[i]]];
return r;
}

template <typename T>
NRPerm<T> NRPerm<T>::commutator(const NRPerm<T> &q, bool inverse) const
{
#ifdef DEBUG
        if(!this->is_valid() || !q.is_valid()) laerror("multiplication of invalid permutation");
#endif

T n=this->size();
if(n!=q.size()) laerror("product of incompatible permutations");
NRPerm<T> qi=q.inverse();
NRPerm<T> pi=this->inverse();
NRPerm<T> r(n);
if(inverse)  for(T i=1; i<=n; ++i) r[i] = qi[pi[q[(*this)[i]]]];
else for(T i=1; i<=n; ++i) r[i] = pi[qi[(*this)[q[i]]]];
return r;
}



template <typename T>
CyclePerm<T> CyclePerm<T>::conjugate_by(const CyclePerm<T> &q) const
{
#ifdef DEBUG
        if(!this->is_valid() || !q.is_valid()) laerror("multiplication of invalid permutation");
#endif 
return q.inverse()*((*this)*q);
}


//NOTE: for larger permutations it might be more efficient to use cycle decomposition but where exactly the breakeven is?
//at the moment we do it the trivial way for small permutations and using sort for larger ones
template <typename T>
int NRPerm<T>::parity() const
{
if(!this->is_valid()) return 0;
T n=this->size();
if(n==1) return 1;
if(n>=10) //???
	{
	NRPerm<T> tmp(*this);
	return (tmp.sort()&1) ? -1:1;
	}
T count=0;
for(T i=2;i<=n;i++) for(T j=1;j<i;j++) if((*this)[j]>(*this)[i]) count++;
return (count&1)? -1:1;
}

template <typename T>
NRPerm<T>::NRPerm(const CyclePerm<T> &rhs, const int n)
{
#ifdef DEBUG
        if(!rhs.is_valid()) laerror("invalid cycle permutation");
#endif
int m;
if(n) m=n; else m=rhs.max();
this->resize(m);

identity();
T ncycles=rhs.size();
for(T j=1; j<=ncycles; ++j)
        {
	T length= rhs[j].size();
        for(T i=1; i<=length; ++i) (*this)[rhs[j][i]] = rhs[j][i%length+1];
        }
#ifdef DEBUG
if(!is_valid()) laerror("internal error in NRPerm constructor from CyclePerm");
#endif
}

template <typename T>
void NRPerm<T>::randomize(void)
{
int n=this->size();
if(n<=0) laerror("cannot randomize empty permutation");
this->copyonwrite();
this->identity();
for(int i=n-1; i>=1; --i)
	{
	int j= RANDINT32()%(i+1);
	T tmp = (*this)[i+1];
	(*this)[i+1]=(*this)[j+1];
	(*this)[j+1]=tmp;
	}
}


template <typename T>
bool NRPerm<T>::next(void)
{
this->copyonwrite();
int n=this->size();
// Find longest non-increasing suffix and the pivot
int i = n;
while (i > 1 && (*this)[i-1] >= (*this)[i]) --i;
if (i<=1) return false;
T piv=(*this)[i-1];

// Find rightmost element greater than the pivot
int j = n;
while ((*this)[j] <= piv) --j;
// Now the value array[j] will become the new pivot, Assertion: j >= i
    
// Swap the pivot with j
(*this)[i - 1] = (*this)[j];
(*this)[j] = piv;
    
// Reverse the suffix
j = n;
while (i < j) {
        T temp = (*this)[i];
        (*this)[i] = (*this)[j];
        (*this)[j] = temp;
        i++;
        j--;
    }

return true;
}

//Algorithm L from Knuth's volume 4
template <typename T>
PERM_RANK_TYPE NRPerm<T>::generate_all(void (*callback)(const NRPerm<T>&), int select)
{
int n=this->size();
NRVec_from1<T> c((T)0,n);
NRVec_from1<T> d((T)1,n);
int j,k,s;
T q;
T t;

this->identity();
PERM_RANK_TYPE sumperm=0;

p2:
        sumperm++;
        if(callback) {if(!select || (select&1) == (sumperm&1)) {(*callback)(*this); this->copyonwrite();}}
        j=n; s=0;
p4:
        q=c[j]+d[j];
        if(q<0) goto p7;
        if(q==j) goto p6;

        t=(*this)[j-c[j]+s]; (*this)[j-c[j]+s]=(*this)[j-q+s]; (*this)[j-q+s]=t;
        c[j]=q;
        goto p2;
p6:
        if(j==1) goto end;
        s++;
p7:
        d[j]= -d[j];
        j--;
        goto p4;

end:
return select? sumperm/2:sumperm;
}



template <typename T> 
static PermutationAlgebra<T,T>  *list_all_return;

static PERM_RANK_TYPE list_all_index;

template <typename T> 
static void list_all_callback(const NRPerm<T> &p)
{
(*list_all_return<T>)[list_all_index].weight= (list_all_index&1)?-1:1;
(*list_all_return<T>)[list_all_index].perm=p;
(*list_all_return<T>)[list_all_index].perm.copyonwrite();
++list_all_index;
}

template <typename T>
PermutationAlgebra<T,T>  NRPerm<T>::list_all(int parity_sel)
{
PERM_RANK_TYPE number = factorial(this->size());
if(parity_sel) number/=2;
PermutationAlgebra<T,T>  ret(number);
list_all_return<T> = &ret;
list_all_index=0;
this->generate_all(list_all_callback,parity_sel);
return ret;
}




template <typename T, typename R>
bool PermutationAlgebra<T,R>::operator==(PermutationAlgebra<T,R> &rhs)
{
simplify();
rhs.simplify();
if(size()!=rhs.size()) return false;
for(int i=0; i<size(); ++i) if((*this)[i].weight!=rhs[i].weight || (*this)[i].perm!=rhs[i].perm) return false;
return true;
}



//Algorithm L2 from Knuth's volume 4 for multiset permutations
//input must be initialized with (repeated) numbers in any order
template <typename T>
PERM_RANK_TYPE NRPerm<T>::generate_all_multi(void (*callback)(const NRPerm<T>&))
{
PERM_RANK_TYPE sumperm=0;
this->copyonwrite();
myheapsort(this->size(),&(*this)[1],1);
while(1)
        {
        int j,k,l;
        T t;

        sumperm++;
        if(callback) (*callback)(*this);
        j=this->size()-1;
        while(j>0 && (*this)[j]>=(*this)[j+1]) j--;
        if(j==0) break; /*finished*/
        l=this->size();
        while((*this)[j]>=(*this)[l]) l--;
        t=(*this)[j];(*this)[j]=(*this)[l];(*this)[l]=t;
        k=j+1;
        l=this->size();
        while(k<l)
                {
                t=(*this)[k];(*this)[k]=(*this)[l];(*this)[l]=t;
                k++;l--;
                }
        }
return sumperm;
}



template <typename T>
static T _n;

template <typename T>
static void (*_callback)(const NRPerm<T>& ); 

static PERM_RANK_TYPE _sumperm;

template <typename T>
static NRPerm<T> *_perm;

template <typename T>
static void permg(T n)
{
if(n<= _n<T>)
        {
        for(T i=1;i<= _n<T>;i++)
                {
                if(!(*_perm<T>)[i]) //place not occupied
			{
                	(*_perm<T>)[i]=n;
                	permg(n+1);
                	(*_perm<T>)[i]=0;
			}
                }
        }
else
        {
        _sumperm++;
	if(_callback<T>) (*_callback<T>)(*_perm<T>);
        }
}


template <typename T>
PERM_RANK_TYPE NRPerm<T>::generate_all2(void (*callback)(const NRPerm<T>&))
{
this->copyonwrite();
this->clear();
_n<T> = this->size();
_callback<T> =callback;
_sumperm=0;
_perm<T> = this;
permg(1);
return _sumperm;
}


template <typename T>
PERM_RANK_TYPE NRPerm<T>::generate_all_lex(void (*callback)(const NRPerm<T>&))
{
PERM_RANK_TYPE np=0;
this->identity();
do{
++np;
if(callback) (*callback)(*this);
}while(this->next());
return np;
}

template <typename T>
PermutationAlgebra<T,T>  NRPerm<T>::list_all_lex()
{       
PERM_RANK_TYPE number = factorial(this->size());
PermutationAlgebra<T,T>  ret(number);
PERM_RANK_TYPE np=0;
this->identity();
do{
ret[np].perm = *this; ret[np].perm.copyonwrite();
ret[np].weight=0;
++np;
}while(this->next());
return ret;
}



template <typename T>
static T _n2;

template <typename T>
static void (*_callback2)(const NRPerm<T>& );

static PERM_RANK_TYPE _sumperm2;

template <typename T>
static NRPerm<T> *_perm2;

template <typename T>
static const T *pclasses2;


static int sameclass;

template <typename T>
static void permg2(T n) //place number n in a free box in all possible ways and according to restrictions
{
T i;
if(n<=_n2<T>)
        {
        T c=pclasses2<T>[n];
        for(i=1;i<=_n2<T>;i++)
                {
                if((*_perm2<T>)[i]>=1) goto skipme; /*place already occupied*/
                if (sameclass)
                        {
                        if(sameclass==1 && c!=pclasses2<T>[i]) goto skipme;
                        if(sameclass== -1 && c==pclasses2<T>[i] ) goto skipme;
                        if(sameclass== -2) /*allow only permutations which leave elements of each class sorted*/
                                {
                                T j,k;
                                for(j=i+1; j<=_n2<T>; j++)
                                        if((k=(*_perm2<T>)[j])>=1)
                                                 if(/* automatically fulfilled k<n &&*/ c==pclasses2<T>[k]) goto skipme;
                                }
                        }
                /*put it there and next number*/
                (*_perm2<T>)[i]=n;
                permg2(n+1);
                (*_perm2<T>)[i]=0;
                skipme:;
                }
        }
else
        {
        _sumperm2++;
	if(_callback2<T>) {(*_callback2<T>)(*_perm2<T>); _perm2<T> -> copyonwrite();}
        }
}




template <typename T>
PERM_RANK_TYPE NRPerm<T>::generate_restricted(void (*callback)(const NRPerm<T>&), const NRVec_from1<T> &classes, int restriction_type)
{
this->copyonwrite();
this->clear();
_n2<T> = this->size();
_callback2<T> =callback;
_sumperm2=0;
_perm2<T> = this;
pclasses2<T> = &classes[1]-1;
sameclass=restriction_type;
permg2<T>(1);
return _sumperm2;
}

template <typename T> 
static PermutationAlgebra<T,T>  *list_restricted_return;

static PERM_RANK_TYPE list_restricted_index;

static bool list_restricted_invert;

template <typename T> 
static void list_restricted_callback(const NRPerm<T> &p)
{
(*list_restricted_return<T>)[list_restricted_index].weight=p.parity();
(*list_restricted_return<T>)[list_restricted_index].perm= list_restricted_invert?p.inverse():p;
(*list_restricted_return<T>)[list_restricted_index].perm.copyonwrite();
++list_restricted_index;
}

template <typename T>
PermutationAlgebra<T,T>  NRPerm<T>::list_restricted(const NRVec_from1<T> &classes, int restriction_type, bool invert)
{
PERM_RANK_TYPE number = this->generate_restricted(NULL,classes,restriction_type);
PermutationAlgebra<T,T>  ret(number);
list_restricted_return<T> = &ret;
list_restricted_index=0;
list_restricted_invert=invert;
generate_restricted(list_restricted_callback,classes,restriction_type);
return ret;
}


template <typename T>
PERM_RANK_TYPE NRPerm<T>::rank() const
{
int c,i,k;
PERM_RANK_TYPE r;
int n= this->size();

r=0;
for (k=1; k<=n; ++k)
        {
        T l=(*this)[k];
        c=0;
        for(i=k+1;i<=n;++i) if((*this)[i]<l) ++c;
        r+= c;
	i=n-k;
        if(i) r*= i;
        }
return r;
}


template <typename T>
NRVec_from1<T> NRPerm<T>::inversions(const int type, PERM_RANK_TYPE *prank) const
{
PERM_RANK_TYPE s=0;
int n=this->size();
int j,k;
T l;

NRVec_from1<T> i(n);
i.clear();

switch(type) {
case 3:  /*number of elements right from p[j] smaller < p[j]*/
for(j=1;j<n;++j) /*number of elements right from j smaller <j*/
        {
        l=(*this)[j];
        for(k=n;k>j;--k)
                {
                if((*this)[k]<l) ++i[j];
                }
        }
        break;
case 2: /*number of elements left from p[j] bigger >p[j]*/
for(j=2;j<=n;++j) /*number of elements left from j bigger >j*/
        {
        l=(*this)[j];
        for(k=1;k<j;++k)
                {
                if((*this)[k]>l) ++i[j];
                }
        }
        break;
case 1:
for(j=1;j<=n;++j) /*number of elements right from j smaller <j*/
        {
        for(k=n;k>=1;--k)
                {
                if((*this)[k]==j) break;
                if((*this)[k]<j) ++i[j];
                }
        }
        break;
case 0:
for(j=1;j<=n;++j) /*number of elements left from j bigger >j*/
        {
        for(k=1;k<=n;++k)
                {
                if((*this)[k]==j) break;
                if((*this)[k]>j) ++i[j];
                }
        }
        break;
default: laerror("illegal type in inversions");

if(prank)
	{
	if(type!=3) laerror("rank can be computed from inversions only for type 3");
	l=1;
	for(j=1;j<n;++j)
                {
                l*= j;
                *prank += l*i[n-j];
                }
	}
}

return i;
}

template <typename T>
NRPerm<T>::NRPerm(const int type, const NRVec_from1<T> &i)
{
int n=i.size();
this->resize(n);

int k,l;
T j;

switch(type) {
case 2:
case 1:
        for(l=0,j=1; j<=n; ++j,++l)
                {
                /*shift left and place*/
                for(k=n-l+1; k<=n-i[j]; ++k) (*this)[k-1]=(*this)[k];
                (*this)[n-i[j]]=j;
                }
        break;
case 3:
case 0:
        for(l=0,j=n; j>0; --j,++l)
                {
                /*shift right and place*/
                for(k=l; k>=i[j]+1; --k) (*this)[k+1]=(*this)[k];
                (*this)[i[j]+1]=j;
                }
        break;
default: laerror("illegal type in nrperm from inversions");
}

if(type>=2) (*this) = this->inverse();
}



template <typename T>
NRPerm<T>::NRPerm(const int n, const PERM_RANK_TYPE rank)
{
this->resize(n);
NRVec_from1<T> inv(n) ;
#ifdef DEBUG
if(rank>=factorial(n)) laerror("illegal rank for this n");
#endif
inv[n]=0;
int k;
PERM_RANK_TYPE r=rank;
for(k=n-1; k>=0; --k)
        {
        PERM_RANK_TYPE t;
        t=factorial(k);
        inv[n-k]=r/t;
        r=r%t;
        }

*this =  NRPerm(3,inv);
}



template <typename T, typename R>
PermutationAlgebra<T,R> PermutationAlgebra<T,R>::operator&(const PermutationAlgebra<T,R> &rhs) const
{
PermutationAlgebra<T,R> res(this->size()*rhs.size());
for(int i=0; i<this->size(); ++i)
	for(int j=0; j<rhs.size(); ++j)
		res[i*rhs.size()+j] = (*this)[i]&rhs[j];
return res;
}

template <typename T, typename R>
PermutationAlgebra<T,R> PermutationAlgebra<T,R>::operator|(const PermutationAlgebra<T,R> &rhs) const
{
PermutationAlgebra<T,R> res(this->size()*rhs.size());
for(int i=0; i<this->size(); ++i)
        for(int j=0; j<rhs.size(); ++j)
                res[i*rhs.size()+j] = (*this)[i]|rhs[j];
return res;
}


template <typename T, typename R>
PermutationAlgebra<T,R> PermutationAlgebra<T,R>::operator*(const PermutationAlgebra<T,R> &rhs) const
{
if(this->size()>0 && rhs.size()>0 && (*this)[0].perm.size()!=rhs[0].perm.size()) laerror("permutation sizes do not match");
PermutationAlgebra<T,R> res(this->size()*rhs.size());
for(int i=0; i<this->size(); ++i)
        for(int j=0; j<rhs.size(); ++j)
                res[i*rhs.size()+j] = (*this)[i]*rhs[j];
res.simplify();
return res;
}


template <typename T, typename R>
PermutationAlgebra<T,R> PermutationAlgebra<T,R>::operator+(const PermutationAlgebra<T,R> &rhs) const
{
if(this->size()>0 && rhs.size()>0 && (*this)[0].perm.size()!=rhs[0].perm.size()) laerror("permutation sizes do not match");
PermutationAlgebra<T,R> res=this->concat(rhs);
res.simplify();
return res;
}






////////////////////////////////////////////////////////

template <typename T>
CyclePerm<T>:: CyclePerm(const NRPerm<T> &p)
{
#ifdef DEBUG
        if(!p.is_valid()) laerror("invalid permutation");
#endif
T n=p.size();
NRVec_from1<T> used((T)0,n),tmp(n);
T firstunused=1;
T currentcycle=0;
std::list<NRVec_from1<T> > cyclelist;
do
        {
        //find a cycle starting with first unused element
        T cyclelength=0;
        T next = firstunused;
        do
                {
                ++cyclelength;
                used[next]=1;
                tmp[cyclelength] = next;
                next = p[next];
                }
        while(used[next]==0);
        if(cyclelength>1) //nontrivial cycle
                {
		NRVec_from1<T> cycle(&tmp[1],cyclelength);
		cyclelist.push_front(cycle);
                ++currentcycle;
                }
        while(used[firstunused]) {++firstunused; if(firstunused>n) break;} //find next unused element
        }
while(firstunused<=n);
//convert list to NRVec
this->resize(currentcycle);
T i=1;
for(typename std::list<NRVec_from1<T> >::iterator l=cyclelist.begin(); l!=cyclelist.end(); ++l) (*this)[i++] = *l;
}



template <typename T>
bool CyclePerm<T>::is_valid() const
{
for(T i=1; i<=this->size(); ++i)
	{
	T n=(*this)[i].size();
	if(n<=0) return false;
	for(T j=1; j<=n; ++j)
		{
		T x=(*this)[i][j];
		if(x<=0) return false;

		//now check for illegal duplicity of numbers withis a cycle or across cycles
		for(T ii=i; ii<=this->size(); ++ii)
			{
			T nn=(*this)[ii].size();
			for(T jj=(ii==i?j+1:1); jj<=nn; ++jj)
				{
				T xx=(*this)[ii][jj];
				if(x==xx) return false;
				}
			}
		}
	}
return true;
}


template <typename T>
bool CyclePerm<T>::is_identity() const
{
#ifdef DEBUG
if(!this->is_valid()) laerror("operation with an invalid cycleperm");
#endif
for(T i=1; i<=this->size(); ++i) if((*this)[i].size()>1) return false; //at least one nontrivial cycle
return true;
}


template <typename T>
CyclePerm<T> CyclePerm<T>::inverse() const
{
#ifdef DEBUG
if(!this->is_valid()) laerror("operation with an invalid cycleperm");
#endif

CyclePerm<T> r;
T ncycles=this->size();
r.resize(ncycles);
for(T i=1; i<=ncycles; ++i)
	{
	T length=(*this)[i].size();
	r[i].resize(length);
	//reverse order in cycles (does not matter in cycle lengths 1 and 2 anyway)
	for(T j=1; j<=length; ++j) r[i][j] = (*this)[i][length-j+1];
	}
return r;
}

//multiplication via NRPerm - could there be a more efficient direct algorithm?
template <typename T>
CyclePerm<T> CyclePerm<T>::operator*(const CyclePerm &q) const
{
int m=this->max();
int mm=q.max();
if(mm>m) mm=m;
NRPerm<T> qq(q,m);
NRPerm<T> pp(*this,m);
NRPerm<T> rr=pp*qq;
return CyclePerm<T>(rr);
}


//mixed type multiplications
template <typename T>
NRPerm<T> NRPerm<T>::operator*(const CyclePerm<T> &r) const
{
NRPerm<T> rr(r,this->size());
return *this * rr;
}

template <typename T>
NRPerm<T> CyclePerm<T>::operator*(const NRPerm<T> &r) const
{
NRPerm<T> tt(*this,r.size());
return tt*r;
}

template <typename T>
void CyclePerm<T>::simplify(bool keep1)
{
int j=0;
for(int i=1; i<=this->size(); ++i)
	{
	int il= (*this)[i].size();
	if(keep1 && il>0 || il>1 )
		{
		++j;
		if(j!=i) (*this)[j] = (*this)[i]; //keep this
		}
	}
this->resize(j,true);
}


template <typename T>
int CyclePerm<T>::parity() const
{
#ifdef DEBUG
if(!this->is_valid()) laerror("operation with an invalid cycleperm");
#endif
int n_even_cycles=0;
T ncycles=this->size();
for(T i=1; i<=ncycles; ++i)
        {
        T length=(*this)[i].size();
	if((length&1)==0) ++n_even_cycles;
	}
return (n_even_cycles&1)?-1:1;
}


template <typename T>
PERM_RANK_TYPE  CyclePerm<T>::order() const
{
#ifdef DEBUG
if(!this->is_valid()) laerror("operation with an invalid cycleperm");
#endif
PERM_RANK_TYPE r=1;
T ncycles=this->size();
for(T i=1; i<=ncycles; ++i)
        {
        T length=(*this)[i].size();
	r=lcm(r,(PERM_RANK_TYPE)length);
        }
return r;
}


template <typename T>
CompressedPartition<T> CyclePerm<T>::cycles(T n) const
{
#ifdef DEBUG
if(!this->is_valid()) laerror("operation with an invalid cycleperm");
#endif
if(n==0) n=max();
CompressedPartition<T> r(n); r.clear();
T ncycles=this->size();
for(T i=1; i<=ncycles; ++i)
        {
	T length=(*this)[i].size();
	if(length<=0||length>n) laerror("unexpected cycle length in permutation");
	r[length]++;
	}
//fill in trivial cycles of length one
r[1] += n - r.sum();
if(r[1]<0) laerror("inconsistent cycle lengths in CyclePerm::cycles");
return r;
}


//auxiliary function for input of a permutation in cycle format
//returns pointer after closing bracket or NULL if no cycle found
//or input error
template <typename T>
const char *read1cycle(NRVec_from1<T> &c, const char *p)
{
if(*p==0) return NULL;
const char *openbracket = strchr(p,'(');
if(!openbracket) return NULL;
const char *closebracket = strchr(openbracket+1,')');
if(!closebracket) return NULL;
const char *s = openbracket+1;
int r;
int length=0;
std::list<T> cycle;
do      {
	long int tmp;
        int nchar;
        if(*s==',') ++s;
        r = sscanf(s,"%ld%n",&tmp,&nchar);
        if(r==1)
                {
                ++length;
                s += nchar;
		cycle.push_back((T)tmp);
                }
        }
        while(r==1 && s<closebracket);

//make vector from list
c.resize(length);
int i=0;
for(typename std::list<T>::iterator l=cycle.begin(); l!=cycle.end(); ++l) c[++i] = *l;

return closebracket+1;
}

template <typename T>
void CyclePerm<T>::readfrom(const std::string &line)
{
const char *p=line.c_str();
std::list<NRVec<T> > cyclelist;
int ncycles=0;
int count=0;
NRVec_from1<T> c;
while(p=read1cycle(c,p))
        {
        //printf("cycle %d of length %d read\n",count,c.size());
        if(c.size()!=0) //store a nonempty cycle
                {
                ++count;
		cyclelist.push_back(c);
                }
        }


//convert list to vector
this->resize(count);
T i=0;
for(typename std::list<NRVec<T> >::iterator l=cyclelist.begin(); l!=cyclelist.end(); ++l) (*this)[++i] = *l;
#ifdef DEBUG
if(!this->is_valid()) laerror("readfrom received input of invalid CyclePerm");
#endif
}


template <typename T>
std::istream & operator>>(std::istream &s, CyclePerm<T> &x)
{
std::string l;
getline(s,l);
x.readfrom(l);
return s;
}

template <typename T>
std::ostream & operator<<(std::ostream &s, const CyclePerm<T> &x)
{
for(int i=1; i<=x.size(); ++i)
	{
	s<<"(";
	for(int j=1; j<=x[i].size(); ++j)
		{
		s<<x[i][j];
		if(j<x[i].size()) s<<" ";
		}
	s<<")";
	}
return s;
}


template <typename T>
CyclePerm<T> CyclePerm<T>::pow(const int n, const bool keep1) const
{
#ifdef DEBUG
        if(!this->is_valid()) laerror("power of invalid permutation");
#endif
CyclePerm<T> r;
if(n==0) {r.identity(); return r;}

//probably negative n will work automatically using the modulo approach
std::list<NRVec_from1<T> > cyclelist;
T currentcycle=0;

//go through all our cycles and compute power of each cycle separately
for(int i=1; i<=this->size(); ++i)
	{
	int cyclesize = (*this)[i].size();
	if(cyclesize>0 && keep1 || cyclesize>1)
		{
		int modulo = n%cyclesize;
		if(modulo<0) modulo += cyclesize;
		if(modulo==0) 
			{
			if(keep1) //keep cycles of length 1 to keep info about the size of the permutation
				{
				for(int j=1; j<=cyclesize; ++j) {NRVec_from1<T> c(1); c[1] = (*this)[i][j]; ++currentcycle; cyclelist.push_back(c);}
				}
			}
		else //the nontrivial case
			{
			int nsplit=gcd(modulo,cyclesize);
			int splitsize=cyclesize/nsplit;
			for(int j=0; j<nsplit; ++j) //loop over split cycles
				{
				NRVec_from1<T> c(splitsize);
				for(int k=1; k<=splitsize; ++k) //fill in the cycle
					{
					c[k] = (*this)[i][((k-1)*modulo)%cyclesize + 1 + j];
					}
				++currentcycle; cyclelist.push_back(c);	
				}
			}
		}
	}

//convert list to NRVec
r.resize(currentcycle);
int i=1;
for(typename std::list<NRVec_from1<T> >::iterator l=cyclelist.begin(); l!=cyclelist.end(); ++l) r[i++] = *l;
return r;
}

///////////////////////////////////////////////////////

template <typename T>
PERM_RANK_TYPE CompressedPartition<T>::Sn_class_size() const
{
#ifdef DEBUG
if(!this->is_valid()) laerror("operation with an invalid partition");
#endif
int n=this->size();
PERM_RANK_TYPE r=factorial(n);
for(int i=1; i<=n; ++i) 
	{
	T m=(*this)[i];
	if(i>1 && m>0) r/=longpow(i,m);
	if(m>1) r/=factorial(m);
	}
return r;
}

template <typename T>
PERM_RANK_TYPE Partition<T>::Sn_irrep_dim() const
{
#ifdef DEBUG
if(!this->is_valid()) laerror("operation with an invalid partition");
#endif
int n=this->size();
PERM_RANK_TYPE prod=1;
Partition<T> adj=this->adjoint();
//hook length formula
for(int i=1; i<=adj[1]; ++i) //rows
	for(int j=1; j<= (*this)[i]; ++j) //cols
		prod *= (*this)[i]-j+adj[j]-i+1;

return factorial(n)/prod;
}


/*hammermesh eq 10-25, highest weight == generalized partition of r into n parts*/
template <typename T>
PERM_RANK_TYPE Partition<T>::Un_irrep_dim(const int n) const
{
#ifdef DEBUG
if(!this->is_valid()) laerror("operation with an invalid partition");
#endif
if(nparts()>n) return 0; //too antisymmetric partition
int i,j;
double prod;
int r=this->size();
NRVec_from1<int> p(n);
for(i=1;i<=n;i++) p[i]= (i<=r?(*this)[i]:0)+n-i;
prod=1;
for(j=n;j>=2;j--)
        {
        for(i=1;i<j;i++) prod*= (p[i]-p[j]);
	prod /= factorial(j-1); //can be fractional in the intermediate steps - needs double
	}

return (PERM_RANK_TYPE) (prod+0.2);
}



template <typename T>
Partition<T> Partition<T>::adjoint() const
{
#ifdef DEBUG
if(!this->is_valid()) laerror("operation with an invalid partition");
#endif
int n=this->size();
Partition<T> r(n);
r.clear();
for(int i=1;i<=n;++i)
                {
		int j;
                for(j=1; j<=n&&(*this)[j]>=i; ++j);
                r[i]=j-1;
                }
return r;
}

template <typename T>
Partition<T>::Partition(const YoungTableaux<T> &x)
{
#ifdef DEBUG
if(!x.is_valid()) laerror("operation with an invalid tableaux");
#endif
int nparts=x.size();
int n=0;
for(int i=1; i<=nparts; ++i) n+= x[i].size();
this->resize(n);
this->clear();
for(int i=1; i<=nparts; ++i) (*this)[i]=x[i].size();
}


//aux for the recursive procedure
static PERM_RANK_TYPE partitioncount;
template <typename T> static void (*_pcallback)(const Partition<T>&);
static int partitiontyp;
static int partitiontypabs;
template <typename T> static Partition<T> *partition;

template <typename T>
void partgen(int remain, int pos)
{
int hi,lo;
if(remain==0) {++partitioncount; if(_pcallback<T>) (*_pcallback<T>)(*partition<T>); return;}
if(partitiontyp) lo=(remain+partitiontypabs-pos)/(partitiontypabs-pos+1); else lo=1;
hi=remain;
if(partitiontyp>0) hi -= partitiontypabs-pos;
if(pos>1 && (*partition<T>)[pos-1] < hi) hi= (*partition<T>)[pos-1];
for((*partition<T>)[pos]=hi; (*partition<T>)[pos]>=lo; --(*partition<T>)[pos]) partgen<T>(remain-(*partition<T>)[pos],pos+1);
(*partition<T>)[pos]=0;
}



template <typename T>
PERM_RANK_TYPE Partition<T>::generate_all(void (*callback)(const Partition<T>&), int nparts) 
{
int n=this->size();
if(n==0) return 0;
if(nparts>0 && n<nparts) return 0;

this->copyonwrite();
this->clear();
partitioncount=0;
_pcallback<T> =callback;
partitiontyp=nparts;
partition<T> = this;
partitiontypabs= nparts>=0?nparts:-nparts;
partgen<T>(n,1);
return partitioncount;
}


template <typename T>
std::ostream & operator<<(std::ostream &s, const CompressedPartition<T> &x)
{
int n=x.size();
T sum=0;
for(int i=n; i>0;--i)
	if(x[i])
		{
		s<<i;
		if(x[i]>1) s<<'^'<<x[i];
		sum+= i*x[i];
		if(sum<n) s<<',';
		}
return s;
}



template <typename T>
int Partition<T>::parity() const
{
#ifdef DEBUG
if(!this->is_valid()) laerror("operation with an invalid partition");
#endif
T n_even_cycles=0;
T n=this->size();
for(T i=1; i<=n; ++i)
        {
	if((*this)[i]!=0 && ((*this)[i] &1 ) ==0) ++n_even_cycles;
	}
return (n_even_cycles&1)?-1:1;
}

template <typename T>
int CompressedPartition<T>::parity() const
{
#ifdef DEBUG
if(!this->is_valid()) laerror("operation with an invalid partition");
#endif
T n_even_cycles=0;
T n=this->size();
for(T i=2; i<=n; i+=2) n_even_cycles += (*this)[i];
return (n_even_cycles&1)?-1:1;
}





/*see M. Aigner - Combinatorial Theory - number of partitions of number n*/
#define MAXPART 260
#define MIN(x,y) ((x)<(y)?(x):(y))
/* here even few more columns more could be saved, and also the property part(n,k>=n/2)=part(n-k) could be used */
#define partind(n,k) (((n)-3)*((n)-2)/2+(k)-2)
#define getpart(n,k) (((k)>(n) || (k)<=0 )?0:(((k)==(n) || (k)==1)?1:(part[partind((n),(k))])))

PERM_RANK_TYPE partitions(int n, int k)
{
static PERM_RANK_TYPE part[partind(MAXPART+1,1)]={1};
static PERM_RANK_TYPE npart[MAXPART+1]={0,1,2,3};
static int ntop=3;
int i,j,l;
PERM_RANK_TYPE s;

if( n<=0 || k<-1 ) laerror("Partitions are available only for positive numbers");
if(k== -1) /* total partitions */
	{
	if(n>ntop)(void)partitions(n,3); /* make sure that table is calculated */
	return npart[n];
	}

if(n==k||k==1) return 1;
if(k==0||k>n) return 0;
if(k==2) return n/2;
if(n>MAXPART && k>=n/2) return(partitions(n-k,-1)); 
if( n>MAXPART) laerror("sorry, too big argument to partition enumerator");
if(n<=ntop) return(getpart(n,k));

/*calculate, if necessary, few next rows*/
for(i=4;i<=n;i++)
    {
    npart[i]=2;
    for(j=2;j<=i-1;j++)
	{
	s=0;
	for(l=1; l<=MIN(i-j,j);l++) s+=getpart(i-j,l);
	npart[i]+=(part[partind(i,j)]=s);
	}
    }

ntop=n;
return(part[partind(n,k)]);

}

#undef getpart
#undef partind
#undef MIN



//////////////////////////////////////////////////////////////////////////////////////

template <typename T>
YoungTableaux<T>::YoungTableaux(const Partition<T> &frame)
: NRVec_from1<NRVec_from1<T> >()
{
#ifdef DEBUG
if(!frame.is_valid()) laerror("invalid partition used as young frame");
#endif
int nlines=frame.nparts();
this->resize(nlines);
for(int i=1; i<=nlines; ++i) {(*this)[i].resize(frame[i]); (*this)[i].clear();}
}

template <typename T>
bool YoungTableaux<T>::is_valid() const
{
int nrows=this->size();
for(int i=1; i<=nrows; ++i)
	{
	if((*this)[i].size()<=0) return false;
	if(i>1 && (*this)[i].size()> (*this)[i-1].size()) return false;
	}
return true; 
}


template <typename T>
T YoungTableaux<T>::sum() const
{
#ifdef DEBUG
if(!is_valid()) laerror("invalid young frame");
#endif
int sum=0;
int nrows=this->size();
for(int i=1; i<=nrows; ++i) sum += (*this)[i].size();
return sum;
}

template <typename T>
T YoungTableaux<T>::max() const
{
#ifdef DEBUG
if(!is_valid()) laerror("invalid young frame");
#endif
int m= -1;
int nrows=this->size();
for(int i=1; i<=nrows; ++i) for(int j=1; j<= (*this)[i].size(); ++j) if((*this)[i][j]>m) m=(*this)[i][j];
return m;
}



template <typename T>
bool YoungTableaux<T>::is_standard() const
{
#ifdef DEBUG
if(!is_valid()) laerror("invalid young frame");
#endif
int nrows=this->size();
//check numbers monotonous in rows and columns
for(int i=1; i<=nrows; ++i)
	{
	for(int j=1; j<=(*this)[i].size(); ++j) 
		{
		if(j>1 && (*this)[i][j] < (*this)[i][j-1]) return false;
		if(i>1 && (*this)[i][j] < (*this)[i-1][j]) return false;
		}
	}
return true;
}

template <typename T>
std::ostream & operator<<(std::ostream &s, const YoungTableaux<T> &x)
{
int nrows=x.size();
for(int i=1; i<=nrows; ++i)
        {
	for(int j=1; j<=x[i].size(); ++j)
		{
		s.width(4);
		s<<x[i][j]<<' ';
		}
	s<<std::endl;
	}
return s;
}


template <typename T>
NRVec_from1<T>  YoungTableaux<T>::yamanouchi() const
{
#ifdef DEBUG
if(!is_valid()) laerror("invalid young frame");
#endif
int n=sum();
NRVec_from1<T> yama(n);
int i,j;
for (i=1;i<=this->size();i++) for (j=1;j<=(*this)[i].size();j++) yama[n-(*this)[i][j]+1]=i;
return yama;
}


template <typename T>
T  YoungTableaux<T>::character_contribution(int ncyc) const
{
#ifdef DEBUG
if(!is_valid()) laerror("invalid young frame");
if(!is_standard()) laerror("nonstandardly filled young frame");
#endif


if(!ncyc) ncyc=max(); //number of types of applied points
NRVec_from1<T> onxlines((T)0,ncyc);

for(int i=1;i<=(*this).size();i++) //rows
        {
	NRVec_from1<T> wasfound((T)0,ncyc);
        for(int j=1;j<=(*this)[i].size();j++) //columns
                {
                T k = (*this)[i][j];
                onxlines[k] += (1-wasfound[k]);
                wasfound[k]=1;
                }
        }

/*now sum the number of odd applications for all cycles*/
T contrib=0;
for(int i=1;i<=ncyc;i++) contrib += ((onxlines[i]&1)^1);

return (1-2*(contrib&1)); //add it to the character +1 for even no. of odd apl., -1 for odd no. of odd apl.
}

static bool _callyoung;

template <typename T>
static void (*_young_callback)(const YoungTableaux<T>&);

template <typename T>
static T _character;

template <typename T>
static YoungTableaux<T> *_tchi;

template <typename T>
static T _nowapplying;

template <typename T>
static T _ncycles;

template <typename T>
static NRVec_from1<T> *_aplnumbers;

template <typename T>
static NRVec_from1<T> *_oclin;

template <typename T>
static NRVec_from1<T> *_occol;

template <typename T>
static T _nn;

template <typename T>
static inline T mymin(T i,T j)
{
  return(i<j?i:j);
}


template <typename T>
void placedot(T l, T c)
{
(*_tchi<T>)[l][c]= _nowapplying<T>;
(*_oclin<T>)[l]++;
(*_occol<T>)[c]++;
}

//forward declaration for recursion
template <typename T>
extern void nextapply(T ncyc);

template <typename T>
void regulapply(T ncyc, T napl) //ncyc is number of cycles; napl is the size of now processed cycle 
{

/*the main idea is that only the first point of each set can be placed
in several independent ways; the other points (if present) must be placed in
a given fixed way depending on the first one; than it is also necessary to test
if the application was successfull at all and return back or call nextapply, respectively*/

Partition<T> usedcols(_nn<T>),usedlines(_nn<T>); //stores the positions where points were placed, is necessary for later cleanup

/*try to place first point*/
for(usedlines[1]=mymin((T)_tchi<T>->nrows(),(*_occol<T>)[1]+napl); usedlines[1]>0; usedlines[1]--)
   {
   if((*_oclin<T>)[usedlines[1]]<=(*_tchi<T>)[usedlines[1]].size()) /*line is not fully occupied*/
	{
	int i;

	usedcols[1]= (*_oclin<T>)[usedlines[1]]; /*in the line there is only one possible column*/
	/* place first point */
	placedot(usedlines[1],usedcols[1]);

	for(i=2;i<=napl;i++) usedlines[i]=usedcols[i]= 0; /* flag for cleaning that they were not placed*/
	/*now place other ones, if not possible go to irregular*/
	for(i=2;i<=napl;i++)
		{
		T thisrow;
		thisrow=usedlines[i-1];
		if (thisrow==1)
			{
			if((*_oclin<T>)[1]> (*_tchi<T>)[1].size()) goto irregular; /*no place remained*/ 
			placedot((usedlines[i]=1),(usedcols[i]= (*_oclin<T>)[1]));
			}
		else
			{
			T thiscol;
			thiscol=usedcols[i-1];
			if(!(*_tchi<T>)[thisrow-1][thiscol]) /*the box at the top of last placed is free*/
				{
				placedot((usedlines[i]=thisrow-1),(usedcols[i]=thiscol));
				}
			else if((*_oclin<T>)[thisrow] <= (*_tchi<T>)[thisrow].size()) /*the position at the right exists*/
				{
#ifdef DEBUG
				if((*_tchi<T>)[thisrow][thiscol+1]) laerror("error in regulapply!!!");
#endif
				placedot((usedlines[i]=thisrow),(usedcols[i]=thiscol+1));
				}
			else goto irregular;
			}
		}

	/*test if it is regular*/
	for(i=1;i<=napl;i++)
		{
		/*test if the box left and up from actual position is full (provided it exists)*/
		if(usedlines[i]>1) if(!(*_tchi<T>)[usedlines[i]-1][usedcols[i]]) goto irregular;
		if(usedcols[i]>1)  if(!(*_tchi<T>)[usedlines[i]][usedcols[i]-1]) goto irregular;
		}

	nextapply(ncyc+1);
	
	irregular:

	/* clear all points */
	for(i=napl;i>0;i--)
	    if(usedlines[i]>0 && usedcols[i]>0)
		{
		(*_tchi<T>)[usedlines[i]][usedcols[i]]=0;
		(*_oclin<T>)[usedlines[i]]--;
		(*_occol<T>)[usedcols[i]]--;
		}

	}
   /*end of loop for nonfull lines of first point*/
   }
}


template <typename T>
void nextapply(T ncyc)
{
_nowapplying<T>++;
if(ncyc> _ncycles<T>) 
	{
	if(_callyoung)
		{
		if(_young_callback<T>) _young_callback<T>(*_tchi<T>);
		_character<T> ++;
		}
	else _character<T> += _tchi<T>->character_contribution(_ncycles<T>);
	}
else regulapply(ncyc,(*_aplnumbers<T>)[ncyc]);
_nowapplying<T>--;
}



template <typename T>
T Sn_character(const Partition<T> &irrep, const  Partition<T> &cclass)
{
#ifdef DEBUG
if(!irrep.is_valid()||!cclass.is_valid()) laerror("invalid input to Sn_character");
#endif

//prepare numbers to apply to the tableaux
int n=irrep.sum();
if(cclass.sum()!=n) laerror("irrep and class partitions do not match");
T ncycles=cclass.nparts();

NRVec_from1<T> aplnumbers(ncycles);
CompressedPartition<T> ccclass(cclass);
T k=0;
for(int j=n;j>0;j--) for(T l=1;l<=ccclass[j];l++) aplnumbers[++k]=j;
if(aplnumbers[k]==1)
        {
        /*rotate to the right*/
        for(T l=k;l>1;l--) aplnumbers[l]=aplnumbers[l-1];
        aplnumbers[1]=1;
        }

//applying aplnumbers[i] pieces of "i"
//std::cout<<"TEST aplnumbers "<<aplnumbers<<std::endl;

//prepare static variables for the recursive procedure and generate all regular applications
YoungTableaux<T> y(irrep);
//y.clear(); //already done in the constructor
_callyoung=false;
_ncycles<T> =ncycles;
_tchi<T> = &y;
_nn<T> = n;
_nowapplying<T> =0;
_aplnumbers<T> = &aplnumbers;
_character<T> =0;
Partition<T> oclin(n);
_oclin<T> = &oclin;
Partition<T> occol(n);
_occol<T>  = &occol;
for(int i=1; i<=n; ++i) (*_oclin<T>)[i]= (*_occol<T>)[i]= 1;
nextapply<T>(1);

return _character<T>;
}



template <typename T>
PERM_RANK_TYPE YoungTableaux<T>::generate_all_standard(void (*callback)(const YoungTableaux<T>&))
{
#ifdef DEBUG
if(!this->is_valid()) laerror("invalid young frame");
#endif

//prepare numbers to apply to the tableaux
T n=this->sum();
T ncycles=n;
NRVec_from1<T> aplnumbers(n);
for(T i=1; i<=n; ++i) aplnumbers[i]=1;

//prepare static variables for the recursive procedure and generate all regular applications
this->clear(); 
_callyoung=true;
_young_callback<T> =callback;
_ncycles<T> =ncycles;
_tchi<T> = this;
_nn<T> = n;
_nowapplying<T> =0;
_aplnumbers<T> = &aplnumbers;
_character<T> =0;
Partition<T> oclin(n);
_oclin<T> = &oclin;
Partition<T> occol(n);
_occol<T>  = &occol;
for(int i=1; i<=n; ++i) (*_oclin<T>)[i]= (*_occol<T>)[i]= 1;
nextapply<T>(1);
return _character<T>;
}


////generation of the young operator

template <typename T>
static NRPerm<T> _aperm;

template <typename T>
static NRPerm<T> _sperm;

template <typename T>
static const YoungTableaux<T> *_tyou;

template <typename T>
static const Partition<T> *_tyou_cols;

template <typename T>
static const Partition<T> *_tyou_rows;

static PERM_RANK_TYPE _nyoungterms, _expectterms;

template <typename T>
static T _antparity;

template <typename T, typename R>
PermutationAlgebra<T,R> *_young_r;



template <typename T>
static void symetr(T ilin, T iel)
{

if(ilin > (*_tyou_cols<T>)[1])
	{
	(*_young_r<T,T>)[_nyoungterms].weight = _antparity<T>;
	(*_young_r<T,T>)[_nyoungterms].perm = _aperm<T>*_sperm<T>;
	++_nyoungterms;
	} 
else if(iel > (*_tyou_rows<T>)[ilin]) symetr(ilin+1,(T)1);
else
	{
	int i;

	for(i=1;i<=(*_tyou_rows<T>)[ilin];i++)
	    if(!_sperm<T>[(*_tyou<T>)[ilin][i]])
		{
		_sperm<T>[(*_tyou<T>)[ilin][i]]= (*_tyou<T>)[ilin][iel];
		symetr(ilin,iel+1);
		_sperm<T>[(*_tyou<T>)[ilin][i]]=0;
		}
	}
}




template <typename T>
static void antisym(T icol,T iel)
{

if(icol > (*_tyou_rows<T>)[1])
	{
	_antparity<T> = _aperm<T>.parity();
	symetr<T>(1,1);
	}
else
if(iel > (*_tyou_cols<T>)[icol]) antisym(icol+1,(T)1);
else
	{
	int i;

	for(i=1;i<=(*_tyou_cols<T>)[icol];i++)
	    if(!_aperm<T>[(*_tyou<T>)[i][icol]])
		{
		_aperm<T>[(*_tyou<T>)[i][icol]]= (*_tyou<T>)[iel][icol];
		antisym(icol,iel+1);
		_aperm<T>[(*_tyou<T>)[i][icol]]=0;
		}
	}
}







template <typename T>
PermutationAlgebra<T,T> YoungTableaux<T>::young_operator() const
{
#ifdef DEBUG
if(!this->is_standard()) laerror("young_operator called for non-standard tableaux");
#endif
_nyoungterms =0;
_tyou<T> = this;
Partition<T> rows=Partition<T>(*this);
Partition<T> cols=rows.adjoint();
_tyou_rows<T> = &rows;
_tyou_cols<T> = &cols;

T n=rows.sum();
_aperm<T>.resize(n); _aperm<T>.clear();
_sperm<T>.resize(n); _sperm<T>.clear();


_expectterms=1;
for(int i=1;i<=cols[1];i++) _expectterms *= factorial(rows[i]);
for(int i=1;i<=rows[1];i++) _expectterms *= factorial(cols[i]);

PermutationAlgebra<T,T> r(_expectterms);
_young_r<T,T> = &r;

antisym<T>(1,1);

if(_nyoungterms!=_expectterms) laerror("youngconstruct: inconsistent number of terms");

return r;
}



template <typename T>
static NRVec_from1<CompressedPartition<T> > *_irreps;

template <typename T>
static NRVec_from1<CompressedPartition<T> > *_classes;

template <typename T>
static PERM_RANK_TYPE _ithrough;


template <typename T>
static void _process_partition(const Partition<T> &p)
{
++_ithrough<T>;
(*_irreps<T>)[_ithrough<T>] = CompressedPartition<T>(p);
Partition<T> q=p.adjoint();
(*_classes<T>)[_ithrough<T>] = CompressedPartition<T>(q);
}

template <typename T>
Sn_characters<T>::Sn_characters(const int n0)
:n(n0)
{
Partition<T> p(n);
PERM_RANK_TYPE np = partitions(n);
irreps.resize(np);
classes.resize(np);
classsizes.resize(np);
chi.resize(np,np);
_irreps<T> = &irreps;
_classes<T> = &classes;
_ithrough<T> = 0;
//generate partitions for classes and irreps
PERM_RANK_TYPE tot=p.generate_all(_process_partition<T>);
//compute class sizes
for(int i=1; i<=np; ++i) classsizes[i]= classes[i].Sn_class_size();
//compute characters
for(int i=1; i<=np; ++i) 
	{
	for(int j=1; j<=np; ++j)
		{
		chi(i,j) = Sn_character<T>(irreps[i],classes[j]);
		}
	}
}


template <typename T>
bool Sn_characters<T>::is_valid() const
{
//consistency of n and partition number
PERM_RANK_TYPE np = partitions(n);
if(np!=classes.size() || np!=irreps.size() || np!=classsizes.size() ||np!=chi.nrows() ||np!=chi.ncols()) return false;

//consistency of sum = n in all partitions
for(int i=1; i<=np; ++i) 
	{
	if(irreps[i].sum()!=n) return false;
	if(classes[i].sum()!=n) return false;
	}

//consistency of irrep dim squared to n!
//consistency of irrep dimensions by hook length formula to character of identity (asserted as class no. 1)
if(classes[1][1]!=n) laerror("assetion failed on class no. 1 being identity");
PERM_RANK_TYPE nf = factorial(n);
PERM_RANK_TYPE s=0;
for(int i=1; i<=np; ++i)
        {
	T d=chi(i,1);
	s += d*d;
	T dd=Partition<T>(irreps[i]).Sn_irrep_dim();
	if(d!=dd) return false;
	}
if(s!=nf) return false;

//consistency of class sizes sum to n! 
s=0; for(int i=1; i<=np; ++i) s+= classsizes[i];
if(s!=nf) return false;

//check that irrep [n] is totally symmetric
if(irreps[1][n]!=1)  laerror("assetion failed on first irrep being [n]");
for(int i=1; i<=np; ++i) if(chi(1,i)!=1) return false;

//check that irrep[1^n] is totally antisymmetric
if(irreps[np][1]!=n) laerror("assetion failed on last irrep being [1^n]");
for(int i=1; i<=np; ++i) if(chi(np,i)!=classes[i].parity()) return false;

//check character orthonormality between irreps
for(int i=1; i<=np; ++i) for(int j=1; j<=i; ++j)
	{
	s=0;
	for(int k=1; k<=np; ++k) s+= classsizes[k]*chi(i,k)*chi(j,k);
	if(i==j)
		{
		if(s!=nf) return false;
		}
	else
		{
		if(s!=0) return false;
		}
	}

return true;
}

template <typename T>
std::ostream & operator<<(std::ostream &s, const Sn_characters<T> &c)
{
const int w=4+c.n; //some reasonable width
s<<"S"<<c.n<<" "<<c.classes.size()<<std::endl;
s.width(w); s<<" ";
for(int i=1; i<=c.classes.size(); ++i)
	{
	s.width(w); 
        s<<c.classsizes[i]<<" ";
	}
s<<std::endl;
s.width(w); s<<" ";
for(int i=1; i<=c.classes.size(); ++i) 
	{
	std::ostringstream  classlabel;
	classlabel<<"("<<c.classes[i]<<")";
	s.width(w); 
	s<<classlabel.str()<<" ";
	} 
s<<std::endl;
for(int i=1; i<=c.chi.nrows(); ++i)
	{
	std::ostringstream irrep;
	irrep<<"["<<c.irreps[i]<<"] ";
	s.width(w); s<<irrep.str();
	for(int j=1; j<=c.chi.ncols(); ++j) {s.width(w); s<<c.chi(i,j)<<" ";}
	s<<std::endl;
	}

return s;
}


template <typename T>
bool CycleIndex<T>::is_valid() const
{
if(classes.size()!=classsizes.size()) return false;
T n=classes[1].sum();
for(int i=2; i<=classes.size(); ++i) 
	{
	if(classes[i].sum()!=n) return false;
	}
return true;
}

template <typename T>
Polynomial<T> CycleIndex<T>::substitute(const Polynomial<T> &p, PERM_RANK_TYPE *denom) const
{
Polynomial<T> r(0);
r[0]=(T)0;
*denom =0;

for(int i=1; i<=classes.size(); ++i)
	{
	Polynomial<T> term(0);
	term[0]=(T)1;
	for(int j=1; j<=classes[i].size(); ++j) if(classes[i][j]) term *= (p.powx(j)).pow((int)classes[i][j]);
	r += term*classsizes[i];
	*denom += classsizes[i];
	}

return r;
}


template<typename T>
NRMat<PERM_RANK_TYPE> Multable(T n)
{
NRPerm<T> p(n);
PermutationAlgebra<T,T> all = p.list_all_lex();
NRMat<PERM_RANK_TYPE> r(all.size(),all.size());
for(PERM_RANK_TYPE i=0; i<all.size(); ++i) r[0][i] = r[i][0]=i; //identity
for(PERM_RANK_TYPE i=1; i<all.size(); ++i)
	for(PERM_RANK_TYPE j=1; j<all.size(); ++j)
		{
		NRPerm<T> tmp = all[i].perm * all[j].perm;
		r(i,j) = tmp.rank();
		}
//consistency checks
#ifdef DEBUG
bitvector occ(all.size());
for(PERM_RANK_TYPE i=0; i<all.size(); ++i) 
	{
	occ.clear();
	for(PERM_RANK_TYPE j=0; j<all.size(); ++j) {if(occ[r(i,j)]) laerror("inconsistency in Multable"); occ.set(r(i,j));}
	occ.clear();
	for(PERM_RANK_TYPE j=0; j<all.size(); ++j) {if(occ[r(j,i)]) laerror("inconsistency in Multable"); occ.set(r(j,i));}
	}

#endif
return r;
}

template<typename T, typename R>
NRMat<R> RegularRepresentation(const PermutationAlgebra<T,R> &a, const NRMat<PERM_RANK_TYPE> &mtable)
{
NRMat<R> r(mtable.nrows(),mtable.ncols());
r.clear();
for(int i=0; i<a.size(); ++i)
	{
	PERM_RANK_TYPE rx=a[i].perm.rank();	
	for(PERM_RANK_TYPE j=0; j<mtable.nrows();++j) r(mtable(rx,j),j) += a[i].weight;
	}
return r;
}


template<typename T>
PermutationAlgebra<T,T> general_antisymmetrizer(const NRVec<NRVec_from1<T> > &groups, int restriction_type, bool inverted)
{
PermutationAlgebra<T,T> r;
int ngroups=groups.size();
if(ngroups==0) return r;
NRVec<PermutationAlgebra<T,T> > lists(ngroups);
for(int i=0; i<ngroups; ++i)
	{
	int ni = groups[i].size();
	NRPerm<T> tmp(ni);
	lists[i] = tmp.list_restricted(groups[i],restriction_type,inverted);
	}
//cross-product the lists
r=lists[0];
for(int i=1; i<ngroups; ++i) r= r&lists[i];
return r;
}


/***************************************************************************//**
 * forced instantization in the corresponding object file
 ******************************************************************************/

#define INSTANTIZE(T) \
template class NRPerm<T>; \
template class CyclePerm<T>; \
template class CompressedPartition<T>; \
template class Partition<T>; \
template class YoungTableaux<T>; \
template class Sn_characters<T>; \
template class CycleIndex<T>; \
template NRMat<PERM_RANK_TYPE> Multable(T n); \
template PermutationAlgebra<T,T> general_antisymmetrizer(const NRVec<NRVec_from1<T> > &groups, int, bool); \
template std::istream & operator>>(std::istream &s, CyclePerm<T> &x); \
template std::ostream & operator<<(std::ostream &s, const CyclePerm<T> &x); \
template std::ostream & operator<<(std::ostream &s, const CompressedPartition<T> &x); \
template std::ostream & operator<<(std::ostream &s, const YoungTableaux<T> &x); \
template T Sn_character(const Partition<T> &irrep, const  Partition<T> &cclass); \
template std::ostream & operator<<(std::ostream &s, const Sn_characters<T> &x); \


#define INSTANTIZE2(T,R) \
template class WeightPermutation<T,R>; \
template class PermutationAlgebra<T,R>; \
template std::istream & operator>>(std::istream &s, WeightPermutation<T,R> &x); \
template std::ostream & operator<<(std::ostream &s, const WeightPermutation<T,R> &x); \
template NRMat<R> RegularRepresentation(const PermutationAlgebra<T,R> &a, const NRMat<PERM_RANK_TYPE> &mtable); \


INSTANTIZE(int)
INSTANTIZE(unsigned int)


INSTANTIZE2(int,int)


INSTANTIZE2(int,double)

}//namespace