permutation.h

/* -*- c++ -*- */
/*
 * Expresso, a C++ Array template class library
 * Copyright (C) 1998,2004 Oskar Enoksson (enok@lysator.liu.se)
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library 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
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA  02111-1307, USA.
 */
#ifndef EXPRESSO_PERMUTATION_HDR
#define EXPRESSO_PERMUTATION_HDR

#include "debug.h"
#include "tmpltool.h"
#include "ixtype.h"

namespace esso {

  template<int N>
  class Permutation: protected Ix<N,DIMT> {
  public:
    template<int NN>
    friend class Permutation;



    inline Permutation() {
      for(int n=0; n<N; n++)
        this->d[n]= n;
    }
    explicit inline Permutation(int r) {
      if(r>=0)
        for(int n=0; n<N; n++)
          this->d[n] = (n+r)%N;
      else
        for(int n=0; n<N; n++)
          this->d[n] = N-1-(N-1-(n+r))%N;
    }



    inline DIMT operator[](DIMT n) const { 
      return this->d[n]; 
    }
    inline bool operator == (const Permutation<N> &src) const {
      return Ix<N,DIMT>::operator == (src);
    }
    inline bool operator != (const Permutation<N> &src) const {
      return Ix<N,DIMT>::operator != (src);
    }
    template<class TT>
    inline Ix<N,TT> operator *(const Ix<N,TT> &i) const { 
      Ix<N,TT> tmp;
      for(int n=0; n<N; n++)
        tmp[this->d[n]]=i[n];
      return tmp;
    }
    inline Permutation<N> operator *(const Permutation<N> &p) const { 
      Permutation<N> tmp;
      for(int n=0; n<N; n++)
        tmp.d[n]=this->d[p[n]];
      return tmp;
    }
    inline Permutation<N> operator [](const Permutation<N> &p) const { 
      Permutation<N> tmp;
      for(int n=0; n<N; n++)
        tmp.d[this->d[n]]=this->d[p[n]];
      return tmp;
    }
    inline bool IsEven() const {
      Permutation tmp(*this);
      bool iseven = true;
      for(int n=0; n<N-1; n++) {
        if(tmp[n]!=n) {
          int m=n+1;
          while(tmp[m]!=n)
            m++;
          tmp.d[m] = tmp[n];
          tmp.d[n] = n;
          iseven = !iseven;
        }
      }
      return iseven;
    }



    inline bool Setup(const Ix<N,DIMT> &src) {
      Ix<N,DIMT> tst(0);
      for(int n=0; n<N; n++) {
        if(src[n]<0 ||src[n]>=N)
          return false;
        if(tst[n]++>0)
          return false;
      }
      Ix<N,DIMT>::operator =(src);
      return true;
    }
    inline bool SetupSwap(DIMT n1, DIMT n2) {
      if(n1<0 || n1>=N || n2<0 || n2>=N)
        return false;
      for(int n=0; n<N; n++)
        this->d[n] = n;
      this->d[n1] = n2;
      this->d[n2] = n1;
      return true;
    }
    inline Permutation<N> &Invert() {
      Permutation<N> tmp;
      for(int n=0; n<N; n++)
        tmp.d[this->d[n]]=n;
      return operator =(tmp);
    }
    inline Permutation<N> operator ~() const {
      return Permutation(*this).Invert();
    }
    template<int N1>
    inline Permutation<N> &Concat(const Permutation<N1> &p1, 
                                  const Permutation<N-N1> &p2) {
      for(int n=0; n<N1; n++)
        this->d[n] = p1[n];
      for(int n=0; n<N-N1; n++)
        this->d[n+N1] = p2[n]+N1;
      return *this;
    }
    template<int M>
    inline Permutation<N+M> operator | (const Permutation<M> &p2) const {
      return Permutation<N+M>().Concat(*this,p2);
    }
  };
}

#endif

---