size.h

Go to the documentation of this file.

/*
  Copyright (C) 2004,2005 Fokko du Cloux
  part of the Atlas of Lie Groups and Representations

  For license information see the LICENSE file
*/

#ifndef SIZE_H  /* guard against multiple inclusions */
#define SIZE_H

#include "size_fwd.h"

#include <cstring>
#include "constants.h"

/******** type declarations **************************************************/

namespace atlas {



/******** constant declarations **********************************************/

namespace size {

  template<unsigned long n> class PrimesMax
  {
  public:
    static const unsigned long value; // no value supplied in generic case
  };


  // predefined values for likely instances of RANK_MAX
  template<> class PrimesMax<8> {
  public:
    static const unsigned long value = 4ul;
  };

  template<> class PrimesMax<16> {
  public:
    static const unsigned long value = 7ul;
  };

  template<> class PrimesMax<32> {
  public:
    static const unsigned long value = 11ul;
  };

  template<> class PrimesMax<64> {
  public:
    static const unsigned long value = 18ul;
  };

  const size_t PRIMES_MAX = PrimesMax<constants::RANK_MAX>::value;

}  // |namespace size|

/******** function declarations **********************************************/

namespace size {

  unsigned long prime(size_t);

  Size factorial (unsigned long n);

}

/******** type definitions ***************************************************/

namespace size {

template<typename C> class SizeType
{
  C d_exp[PRIMES_MAX];

 public:
// constructors and destructors
  SizeType() { std::memset(d_exp,0,PRIMES_MAX*sizeof(C)); }

  explicit SizeType(unsigned long);

// copy and assignment (defaults suffice)

// accessors
  C operator[] (size_t j) const { return d_exp[j]; }

  bool operator== (const SizeType& c) const
    { return std::memcmp(d_exp,c.d_exp,PRIMES_MAX*sizeof(C))==0; }
  bool operator!= (const SizeType& c) const
    { return std::memcmp(d_exp,c.d_exp,PRIMES_MAX*sizeof(C))!=0; }

  unsigned long piece(size_t) const; // return $prime(i)^{d_exp[i]}$
  unsigned long toUlong() const;     // try to represent as unsigned long

// manipulators
  C& operator[] (size_t j) { return d_exp[j]; }

  SizeType& operator*= (const SizeType&);

  SizeType& operator*= (unsigned long n) { return operator*=(SizeType(n)); }

  SizeType& operator/= (const SizeType&);

  void reset() { std::memset(d_exp,0,PRIMES_MAX*sizeof(C)); }

  void twoShift(C n) // multiplication by 2^n; prime #0 is 2
    { d_exp[0] += n; }
};  // |template<typename C> class SizeType|

}  // |namespace size|

}  // |namespace atlas|

#endif