Some common d sqm ////////////////////////////////////////////////////////. More...

Inheritance diagram for inlib::E< T >:

Collaboration diagram for inlib::E< T >:

Public Member Functions
	E (unsigned int a_order, unsigned int a_index)
virtual	~E ()
	E (const E &a_from)
E &	operator= (const E &a_from)
Static Public Member Functions
static bool	group_constants (unsigned int a_order, inlib::array< T > &a_constants)
static bool	metric (unsigned int a_order, sqm< T > &a_metric)
static bool	cartan_metric (unsigned int a_order, sqm< T > &a_metric)
static bool	casimir (unsigned int a_order, sqm< T > &a_casimir)

Detailed Description

template<class T>
class inlib::E< T >

Some common d sqm ////////////////////////////////////////////////////////.

Definition at line 527 of file sqm.

Constructor & Destructor Documentation

template<class T>

inlib::E< T >::E	(	unsigned int	a_order,
		unsigned int	a_index
	)		`[inline]`

Definition at line 683 of file sqm.

                                              : sqm<double>(a_order){
    if(!initialize(a_order,a_index)) return; //FIXME : throw
  }

template<class T>

virtual inlib::E< T >::~E ( ) [inline, virtual]

Definition at line 686 of file sqm.

{}

template<class T>

inlib::E< T >::E ( const E< T > & a_from ) [inline]

Definition at line 688 of file sqm.

: sqm<T>(a_from){}

Member Function Documentation

template<class T>

static bool inlib::E< T >::cartan_metric	(	unsigned int	a_order,
		sqm< T > &	a_metric
	)		`[inline, static]`

Definition at line 610 of file sqm.

                                                                   {
    // For order n : -(2*n-4))*I(n*(n-1)/2)
    unsigned int number = a_order * (a_order-1)/2;
  
    array<T> csts;
    if(!E<T>::group_constants(a_order,csts)) {
      a_metric.clear();
      return false;
    }
  
    // Fill the adjoint representation :
    //      r        r
    //  (Xk)  = cst
    //      c      kc
    std::vector< sqm<T> > xs;
    for(unsigned int index=0;index<number;index++) {
      sqm<T> x(number);
      for(unsigned int j=0;j<number;j++) {
        for(unsigned int k=0;k<number;k++) {
          std::vector<unsigned int> is(3);
          is[0] = index;
          is[1] = k;
          is[2] = j;
          T value;
          if(!csts.value(is,value)) return false;
          if(!x.set_value(j,k,value)) return false;
        }
      }
      xs.push_back(x);
    }
  
    a_metric.set_order(number);
  
    for(unsigned int j=0;j<number;j++) {
      for(unsigned int k=0;k<number;k++) {
        sqm<T> mx = xs[j]*xs[k];
        if(!a_metric.set_value(j,k,mx.trace())) return false;
      }
    }
  
    return true;
  }

template<class T>

static bool inlib::E< T >::casimir	(	unsigned int	a_order,
		sqm< T > &	a_casimir
	)		`[inline, static]`

Definition at line 653 of file sqm.

                                                              {
    //  For order n : (n-1)/2 * I(n)
    unsigned int number = a_order * (a_order-1)/2;
  
    sqm<T> metric(number);
    if(!E<T>::metric(a_order,metric)) {
      a_casimir.clear();
      return false;
    }
  
    sqm<T> metric_inv(number);
    if(!metric.invert(metric_inv)) return false;
  
    a_casimir.set_order(a_order);
  
    std::vector< sqm<T> > Es;
    for(unsigned int index=0;index<number;index++)
      Es.push_back(E<T>(a_order,index));
  
    for(unsigned int j=0;j<number;j++) {
      for(unsigned int k=0;k<number;k++) {
        sqm<T> mx = Es[j]*Es[k];
        mx.multiply(metric_inv.value(j,k));
        a_casimir.add(mx);
      }
    }
  
    return true;
  }

template<class T>

static bool inlib::E< T >::group_constants	(	unsigned int	a_order,
		inlib::array< T > &	a_constants
	)		`[inline, static]`

Definition at line 529 of file sqm.

                                                                               {
    unsigned int number = a_order * (a_order-1)/2;
  
    std::vector<unsigned int> orders(3,number);
    a_constants.configure(orders);
  
    std::vector< sqm<T> > Es;
    for(unsigned int index=0;index<number;index++)
      Es.push_back(E(a_order,index));

    sqm<T> zero(a_order);
  
    for(unsigned int j=0;j<number;j++) {
      for(unsigned int k=j+1;k<number;k++) {
        sqm<T> cm = commutator(Es[j],Es[k]);
  
        // Find the result in the Es themselves :
        bool found = false;
        for(unsigned int l=0;l<number;l++) {
          if(cm.equal(zero)) {
            found = true; 
            break;
          } else if(cm.equal(Es[l])) {
            std::vector<unsigned int> is(3);
            is[0] = j;
            is[1] = k;
            is[2] = l;
            a_constants.set_value(is,1);
            is[0] = k;
            is[1] = j;
            is[2] = l;
            a_constants.set_value(is,-1);
  
            found = true; 
            break;
          } else {
            sqm<T> tmp(cm);
            tmp.multiply(-1.);
            if(tmp.equal(Es[l])) {
              std::vector<unsigned int> is(3);
              is[0] = j;
              is[1] = k;
              is[2] = l;
              a_constants.set_value(is,-1);
              is[0] = k;
              is[1] = j;
              is[2] = l;
              a_constants.set_value(is,1);
  
              found = true; 
              break;
            }
          }
        }
        if(!found) {
          a_constants.clear();
          return false;
        }
      }
    }
    return true;
  }

template<class T>

static bool inlib::E< T >::metric	(	unsigned int	a_order,
		sqm< T > &	a_metric
	)		`[inline, static]`

Definition at line 591 of file sqm.

                                                            {
    // For order n : -2*I(n*(n-1)/2) for all orders.
    unsigned int number = a_order * (a_order-1)/2;
  
    std::vector< sqm<T> > Es;
    for(unsigned int index=0;index<number;index++)
      Es.push_back(E<T>(a_order,index));
  
    a_metric.set_order(number);
  
    for(unsigned int j=0;j<number;j++) {
      for(unsigned int k=0;k<number;k++) {
        sqm<T> mx = Es[j]*Es[k];
        if(!a_metric.set_value(j,k,mx.trace())) return false;
      }
    }
  
    return true;
  }

template<class T>

E& inlib::E< T >::operator= ( const E< T > & a_from ) [inline]

Definition at line 689 of file sqm.

                                {
    inlib::sqm<T>::operator=(a_from);
    return *this;
  }

The documentation for this class was generated from the following file:

/Users/barrand/private/dev/softinex/old/inexlib-1.2/inlib/inlib/sqm

Public Member Functions

Static Public Member Functions

Detailed Description

template<class T> class inlib::E< T >

Constructor & Destructor Documentation

Member Function Documentation

template<class T>
class inlib::E< T >