Tensor.h

Go to the documentation of this file.

// Copyright (C) 2003 Johan Hoffman and Anders Logg.
// Licensed under the GNU GPL Version 2.

#ifndef __TENSOR_H
#define __TENSOR_H

namespace dolfin {


  template <class T> class Tensor {
  public:

    Tensor();
    
    Tensor(int order, int dim);

    Tensor(const Tensor& t);

    ~Tensor();

    void init(int order, int dim);

    void clear();
    
    T& operator() (int i0);
    
    T& operator() (int i0, int i1);
    
    T& operator() (int i0, int i1, int i2);
    
    T& operator() (int* i);

    void operator=(const Tensor<T>& t);
    
  private:
    
    int order;  // Order of tensor (number of indices)
    int dim;    // Dimension
    int size;   // Total number of elements (dim^order)
    int *index; // Powers of dim
    
    T *data;
    
  };

  //---------------------------------------------------------------------------
  // Implementation of Tensor
  //---------------------------------------------------------------------------
  template <class T> Tensor<T>::Tensor() 
  {
    order = 0;
    dim = 0;
    size = 0;
    index = 0;
    data = 0;
  }
  //---------------------------------------------------------------------------
  template <class T> Tensor<T>::Tensor(int order, int dim)
  {
    dolfin_assert(order > 0);
    dolfin_assert(dim > 0);

    this->order = 0;
    this->dim = 0;
    size = 0;
    index = 0;
    data = 0;
    
    init(order, dim);
  }
  //---------------------------------------------------------------------------
  template <class T> Tensor<T>::Tensor(const Tensor& t)
  {
    order = 0;
    dim = 0;
    size = 0;
    index = 0;
    data = 0;

    *this = t;
  }
  //---------------------------------------------------------------------------
  template <class T> Tensor<T>::~Tensor()
  {
    clear();
  }
  //---------------------------------------------------------------------------
  template <class T> void Tensor<T>::init(int order, int dim)
  {
    dolfin_assert(order > 0);
    dolfin_assert(dim > 0);

    clear();
    
    this->order = order;
    this->dim = dim;
    
    // Initialise the powers of dim: index = [ dim^(order-1) ... 1 ]
    index = new int[order];
    for (int i = order - 1; i >= 0; i--) {
      if ( i == (order - 1) )
        index[i] = 1;
      else
        index[i] = index[i+1] * dim;
    }
    
    // Initialise the tensor
    size = index[0] * dim;
    data = new T[size];
    for (int i = 0; i < size; i++)
      data[i] = 0;
    
  }
  //---------------------------------------------------------------------------
  template <class T> void Tensor<T>::clear()
  {
    order = 0;
    dim = 0;
    size = 0;
    
    if ( index )
      delete [] index;
    index = 0;
    
    if ( data )
      delete [] data;
    data = 0;
  }
  //---------------------------------------------------------------------------    
  template <class T> T& Tensor<T>::operator() (int i0)
  {
    return data[i0];
  }
  //---------------------------------------------------------------------------    
  template <class T> T& Tensor<T>::operator() (int i0, int i1)
  {
    return data[i0*index[0] + i1];
  }
  //---------------------------------------------------------------------------    
  template <class T> T& Tensor<T>::operator() (int i0, int i1, int i2)
  {
    return data[i0*index[0] + i1*index[1] + i2];
  }
  //---------------------------------------------------------------------------    
  template <class T>  T& Tensor<T>::operator() (int* i)
  {
    int ii = 0;
    for (int j = 0; j < order; j++)
      ii += i[j] * index[j];
    return data[ii];
  }
  //---------------------------------------------------------------------------    
  template <class T> void Tensor<T>::operator= (const Tensor<T>& t)
  {
    clear();
    init(t.order, t.dim);
    
    for (int i = 0; i < size; i++)
      data[i] = t.data[i];
  }
  //---------------------------------------------------------------------------    
  
}

#endif

Documentation automatically generated with Doxygen on 10 Sep 2004.