mirror of
https://github.com/triqs/dft_tools
synced 2024-11-01 03:33:50 +01:00
100 lines
5.1 KiB
C++
100 lines
5.1 KiB
C++
/*******************************************************************************
|
|
*
|
|
* TRIQS: a Toolbox for Research in Interacting Quantum Systems
|
|
*
|
|
* Copyright (C) 2011 by O. Parcollet
|
|
*
|
|
* TRIQS 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.
|
|
*
|
|
* TRIQS 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
|
|
* TRIQS. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
******************************************************************************/
|
|
#ifndef TRIQS_ARRAYS_PERMUTATIONS2_H
|
|
#define TRIQS_ARRAYS_PERMUTATIONS2_H
|
|
namespace triqs { namespace arrays { namespace permutations {
|
|
|
|
typedef unsigned long long ull;
|
|
|
|
constexpr ull apply(ull p, ull i) { return (p >> (4*(i+1))) & 0xFull;}
|
|
constexpr ull size( ull p) { return p & 0xFull;}
|
|
|
|
inline ull permutation_from_array ( const int * const p, int length) {
|
|
ull res =0;
|
|
for (int i =length-1; i>=0; --i) res = p[i] + 0x10*res;
|
|
res= 0x10 * res + length;
|
|
return res;
|
|
}
|
|
|
|
// icc 13.0 has a big bug in constexpr.
|
|
#ifndef TRIQS_WORKAROUND_INTEL_COMPILER_BUGS
|
|
|
|
// sum_{k=0}^{n-1} k a^k = ( (n-1) * a**(n+1) - n * a**n + a)/(a-1)**2
|
|
// sum_{k=0}^{n-1} k a^(n-k-1) = ( (n-1) - n * a + a**n)/(a-1)**2
|
|
// with a = 16, a**n = 1<<4n
|
|
constexpr ull _identity(ull n) { return ( (n-1ull)*(1ull<<(4*(n+1))) +(1ull<<4)- n *(1ull<<(4*n))) /( (1ull<<4) -1ull) /((1ull<<4) -1ull); }
|
|
constexpr ull identity(ull n) { return n + 0x10 * _identity(n);}
|
|
|
|
constexpr ull _ridentity(ull n) { return ( (n-1ull) - n* (1ull<<4) + (1ull<<(4*n))) /( (1ull<<4) -1ull) /((1ull<<4) -1ull); }
|
|
constexpr ull ridentity(ull n) { return n + 0x10 *_ridentity(n); }
|
|
|
|
constexpr ull make_perm_impl(){ return 0;}
|
|
template<typename ... T> constexpr ull make_perm_impl(ull i0, T... x) { return i0 + 0x10 * make_perm_impl(x...); }
|
|
template<typename ... T> constexpr ull permutation(T... x) { return ull(sizeof...(T)) + 0x10* make_perm_impl(x...); }
|
|
|
|
constexpr ull compose_impl(ull p1, ull p2, ull c) { return apply(p2, apply(p1,c)) + 16ull * ( (c+1 <size(p1) ? compose_impl(p1,p2,c+1ull) : 0)); }
|
|
constexpr ull compose(ull p1, ull p2) { return size(p1) + 0x10* compose_impl(p1,p2, 0);}
|
|
|
|
constexpr ull inverse_impl(ull p, ull c) { return (c << (4*apply(p,c))) + (c>0 ? inverse_impl(p,c-1): 0 ); }
|
|
constexpr ull inverse(ull p) { return size(p) + 0x10ull*inverse_impl(p,size(p)-1);}
|
|
|
|
#else
|
|
|
|
constexpr ull _identity(ull n) { return ( (n-1ull)*(1ull<<(4*(n+1))) +(1ull<<4)- n *(1ull<<(4*n))) /( (1ull<<4) -1ull) /((1ull<<4) -1ull); }
|
|
constexpr ull identity(ull n) { return n + 0x10 * _identity(n);}
|
|
|
|
constexpr ull _ridentity(ull n) { return ( (n-1ull) - n* (1ull<<4) + (1ull<<(4*n))) /( (1ull<<4) -1ull) /((1ull<<4) -1ull); }
|
|
constexpr ull ridentity(ull n) { return n + 0x10 *_ridentity(n); }
|
|
|
|
// todo generalize with preproc...
|
|
constexpr ull make_perm_impl(ull i0) { return i0;}
|
|
constexpr ull make_perm_impl(ull i0, ull i1) { return i0 + 0x10ull * i1;}
|
|
constexpr ull make_perm_impl(ull i0, ull i1, ull i2) { return i0 + 0x10ull *make_perm_impl(i1,i2);}
|
|
constexpr ull make_perm_impl(ull i0, ull i1, ull i2, ull i3) { return i0 + 0x10ull *make_perm_impl(i1,i2,i3);}
|
|
constexpr ull make_perm_impl(ull i0, ull i1, ull i2, ull i3, ull i4) { return i0 + 0x10ull * make_perm_impl(i1,i2,i3,i4); }
|
|
|
|
constexpr ull permutation(ull i0) { return 1ull + 0x10ull *make_perm_impl(i0);}
|
|
constexpr ull permutation(ull i0, ull i1) { return 2ull + 0x10ull *make_perm_impl(i0,i1);}
|
|
constexpr ull permutation(ull i0, ull i1, ull i2) { return 3ull + 0x10ull *make_perm_impl(i0,i1,i2);}
|
|
constexpr ull permutation(ull i0, ull i1, ull i2, ull i3) { return 4ull + 0x10ull *make_perm_impl(i0,i1,i2,i3);}
|
|
constexpr ull permutation(ull i0, ull i1, ull i2, ull i3, ull i4) { return 5ull + 0x10ull *make_perm_impl(i0,i1,i2,i3,i4);}
|
|
|
|
template<int c> struct _compose { static constexpr ull invoke(ull p1, ull p2) { return apply(p2, apply(p1,c)) + 16ull * _compose<c+1>::invoke(p1,p2); } };
|
|
template<> struct _compose<15> { static constexpr ull invoke(ull p1, ull p2) { return 0ull; } };
|
|
constexpr ull compose(ull p1, ull p2) { return size(p1) + 0x10ull* (_compose<0>::invoke(p1,p2) & ((1ull<<4*size(p1)) -1ull));}
|
|
|
|
template<int c> struct _inverse { static constexpr ull invoke(ull p) { return (ull(c) << (4*apply(p,c))) + _inverse<c+1>::invoke(p);} };
|
|
template<> struct _inverse<15> { static constexpr ull invoke(ull p) { return 0ull; } };
|
|
constexpr ull inverse(ull p) { return size(p) + 0x10ull*( _inverse<0>::invoke(p) - 7ull*15ull + size(p)*(size(p)-1ull)/2ull);}
|
|
|
|
#endif
|
|
|
|
inline void print( std::ostream & out, ull perm) {
|
|
out << "(";
|
|
for (int i =0; i< permutations::size(perm); ++i) { out << (i!=0 ? " " : "") << apply(perm,i);}
|
|
out << ")";
|
|
}
|
|
}
|
|
using permutations::permutation;
|
|
}}
|
|
#endif
|
|
|