algebra/tensor.h

// -*- c++ -*-

// +--------------------------------------------------------------------+
// | This file is part of MathTL - the Mathematical Template Library    |
// |                                                                    |
// | Copyright (c) 2002-2009                                            |
// | Thorsten Raasch, Manuel Werner                                     |
// +--------------------------------------------------------------------+

#ifndef _MATHTL_TENSOR_H
#define _MATHTL_TENSOR_H

#include <iostream>
#include "algebra/tensor_base.h"

namespace MathTL
{
  template <unsigned int RANK, unsigned int DIM, class VALUE> class Tensor;
  template <unsigned int DIM, class VALUE> class Tensor<1, DIM, VALUE>;

  template <unsigned int RANK, unsigned int DIM, class VALUE = double>
  class Tensor
  {
  public:
    typedef Tensor<RANK-1, DIM, VALUE> value_type;

    typedef size_t size_type;

    static const unsigned int dimension = DIM;

    static const unsigned int rank = RANK;

    Tensor();

    void clear();

    const Tensor<RANK-1, DIM, VALUE>& operator [] (const size_type i) const;

    Tensor<RANK-1, DIM, VALUE>& operator [] (const size_type i);

    Tensor<RANK, DIM, VALUE>& operator = (const Tensor<RANK, DIM, VALUE>&);

    bool operator == (const Tensor<RANK, DIM, VALUE>&) const;

    bool operator != (const Tensor<RANK, DIM, VALUE>&) const;

    Tensor<RANK, DIM, VALUE>& operator += (const Tensor<RANK, DIM, VALUE>&);

    void add(const VALUE s, const Tensor<RANK, DIM, VALUE>& T);
    
    Tensor<RANK, DIM, VALUE>& operator -= (const Tensor<RANK, DIM, VALUE>&);

    Tensor<RANK, DIM, VALUE>& operator *= (const VALUE s);

    Tensor<RANK, DIM, VALUE>& operator /= (const VALUE s);

    Tensor<RANK, DIM, VALUE> operator + (const Tensor<RANK, DIM, VALUE>&) const;

    Tensor<RANK, DIM, VALUE> operator - (const Tensor<RANK, DIM, VALUE>&) const;

    Tensor<RANK, DIM, VALUE> operator - () const;
    
    static const size_type memory_consumption();
    
  protected:
    // internally, we store a tensor of rank r just as a d-dimensional array
    // of tensors of lower rank
    Tensor<RANK-1, DIM, VALUE> subtensor[DIM];
  };

  //
  //
  // external functionality for general tensors

  template <unsigned int RANK, unsigned int DIM, class VALUE>
  std::ostream& operator << (std::ostream& os,
                             const Tensor<RANK, DIM, VALUE>& T);

  template <unsigned int RANK, class VALUE>
    std::ostream& operator << (std::ostream& os,
                               const Tensor<RANK, 1, VALUE>& T);
}

// include implementation of inline functions
#include <algebra/tensor.cpp>

#endif