Tensor4.h

#ifndef QNANO_NEW_TENSOR4_DEFINED_H
#define QNANO_NEW_TENSOR4_DEFINED_H

#include <complex>
#include <iostream>
#include <cstdlib>

class Tensor4{
public:
  //sizes: 
  size_t size[4];
  //data block:
  std::complex<double> *data;
  
  inline size_t get_index(size_t i, size_t j, size_t k, size_t l)const{
    return ((i*size[1]+j)*size[2]+k)*size[3]+l;
  }

public: 
  inline size_t get_totalsize()const{ return size[0]*size[1]*size[2]*size[3];  }

protected:

  void allocate(){  data=new std::complex<double>[get_totalsize()];  }
  void deallocate(){ delete[] data; }
public:
  inline size_t get_size(size_t i)const{return size[i];}
  void resize(size_t i, size_t j, size_t k, size_t l){
    size[0]=i; size[1]=j; size[2]=k; size[3]=l;
    deallocate();
    allocate();
  }
  void set_zero(){ 
    size_t ts=get_totalsize();
    for(size_t i=0; i<ts; i++)data[i]=0.;
  }
  
  const std::complex<double> &operator()(size_t i, size_t j, size_t k, size_t l)const{
    return data[get_index(i,j,k,l)];
  }
  std::complex<double> &operator()(size_t i, size_t j, size_t k, size_t l){
    return data[get_index(i,j,k,l)];
  }
  const std::complex<double> &get_check(int i, int j, int k, int l){
    if(i<0 || i>=(int)size[0] || j<0 || j>=(int)size[1] || k<0 || k>=(int)size[2] || l<0 || l>=(int)size[3]){
      std::cerr<<"Tensor4: out of bounds!"<<std::endl;
      exit(1);
    }
    return data[get_index(i,j,k,l)];
  }
 

  //Constructors and copy operators
  void copy(const Tensor4 &other){
    resize(other.get_size(0),other.get_size(1),other.get_size(2),other.get_size(3));
    for(size_t i=0; i<get_totalsize(); i++){
      data[i]=other.data[i];
    }
  } 
  Tensor4 &operator=(const Tensor4 &other){
    copy(other);
    return *this;
  }
  Tensor4(const Tensor4 &other){
    copy(other);
  }
  Tensor4(){
    size[0]=size[1]=size[2]=size[3]=0;
    allocate();
  } 
  Tensor4(size_t i, size_t j, size_t k, size_t l){
    size[0]=i; size[1]=j; size[2]=k; size[3]=l;
    allocate();
  }
  ~Tensor4(){
    deallocate();
  }
  

};

#endif