jiri
/
LA_library
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
LA_library/permutation.cc

2121 lines
49 KiB
C++
Raw Permalink Blame History

/*
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
Reference in New Issue View Git Blame Copy Permalink