#include "src/ftensor/src/FTensor/Tensor2/Tensor2_pointer.hpp"

Inheritance diagram for FTensor::Tensor2< T *, Tensor_Dim0, Tensor_Dim1 >:

Collaboration diagram for FTensor::Tensor2< T *, Tensor_Dim0, Tensor_Dim1 >:

Public Member Functions
	Tensor2 (T d00, T d01, T d10, T d11, const int i)

	Tensor2 (T d00, T d01, T d10, T d11, T d20, T d21, const int i)

	Tensor2 (T d00, T d01, T d02, T d10, T d11, T d12, T d20, T d21, T *d22, const int i)

	Tensor2 (T d00, T d01, T d02, T d03, T d10, T d11, T d12, T d13, T d20, T d21, T d22, T d23, T d30, T d31, T d32, T d33, const int i)

template<class... U>
	Tensor2 (U *...d)

template<class U >
	Tensor2 (std::array< U , Tensor_Dim0 Tensor_Dim1 > &a, const int i=1)

	Tensor2 ()

	Tensor2 (const int i=1)

T &	operator() (const int N1, const int N2)

T	operator() (const int N1, const int N2) const

T *	ptr (const int N1, const int N2) const

template<char i, char j, int Dim0, int Dim1>
Tensor2_Expr< Tensor2< T *, Tensor_Dim0, Tensor_Dim1 >, T, Dim0, Dim1, i, j >	operator() (const Index< i, Dim0 >, const Index< j, Dim1 >)

template<char i, char j, int Dim0, int Dim1>
Tensor2_Expr< const Tensor2< T *, Tensor_Dim0, Tensor_Dim1 >, T, Dim0, Dim1, i, j >	operator() (const Index< i, Dim0 >, const Index< j, Dim1 > index2) const

template<char i, int Dim, int N>
Tensor1_Expr< Tensor2_number_rhs_1< Tensor2< T *, Tensor_Dim0, Tensor_Dim1 >, T, N >, T, Dim, i >	operator() (const Index< i, Dim >, const Number< N >)

template<char i, int Dim, int N>
Tensor1_Expr< Tensor2_number_rhs_0< Tensor2< T *, Tensor_Dim0, Tensor_Dim1 >, T, N >, T, Dim, i >	operator() (const Number< N >, const Index< i, Dim >)

template<char i, int Dim, int N>
Tensor1_Expr< const Tensor2_number_1< const Tensor2< T *, Tensor_Dim0, Tensor_Dim1 >, T, N >, T, Dim, i >	operator() (const Index< i, Dim >, const Number< N >) const

template<char i, int Dim, int N>
Tensor1_Expr< const Tensor2_number_0< const Tensor2< T *, Tensor_Dim0, Tensor_Dim1 >, T, N >, T, Dim, i >	operator() (const Number< N >, const Index< i, Dim >) const

const Tensor2 &	operator++ () const

template<char i, int Dim>
T	operator() (const Index< i, Dim >, const Index< i, Dim > index2)

template<char i, int Dim>
T	operator() (const Index< i, Dim >, const Index< i, Dim > index2) const

Protected Attributes
T *restrict	data [Tensor_Dim0][Tensor_Dim1]

const int	inc

Private Member Functions
template<int N>
T	internal_contract (Number< N >) const

T	internal_contract (Number< 1 >) const

template<int I>
	Tensor2 (const Tensor2< PackPtr< T *, I >, Tensor_Dim0, Tensor_Dim1 > &)=delete
	Preventing casting on derived class.

template<int G>
	Tensor2 (const Tensor2< CursorPtr< T *, G >, Tensor_Dim0, Tensor_Dim1 > &)=delete

Detailed Description

template<class T, int Tensor_Dim0, int Tensor_Dim1>
class FTensor::Tensor2< T *, Tensor_Dim0, Tensor_Dim1 >

Definition at line 8 of file Tensor2_pointer.hpp.

Constructor & Destructor Documentation

◆ Tensor2() [1/10]

template<class T , int Tensor_Dim0, int Tensor_Dim1>

FTensor::Tensor2< T *, Tensor_Dim0, Tensor_Dim1 >::Tensor2	(	T *	d00,
		T *	d01,
		T *	d10,
		T *	d11,
		const int	i
	)

inline

Definition at line 17 of file Tensor2_pointer.hpp.

                                                       : inc(i) {
    Tensor2_constructor<T *restrict, Tensor_Dim0, Tensor_Dim1, column_major>(
        data, d00, d01, d10, d11);
  }

◆ Tensor2() [2/10]

template<class T , int Tensor_Dim0, int Tensor_Dim1>

FTensor::Tensor2< T *, Tensor_Dim0, Tensor_Dim1 >::Tensor2	(	T *	d00,
		T *	d01,
		T *	d10,
		T *	d11,
		T *	d20,
		T *	d21,
		const int	i
	)

inline

Definition at line 21 of file Tensor2_pointer.hpp.

      : inc(i) {
    Tensor2_constructor<T *restrict, Tensor_Dim0, Tensor_Dim1, column_major>(
        data, d00, d01, d10, d11, d20, d21);
  }

◆ Tensor2() [3/10]

template<class T , int Tensor_Dim0, int Tensor_Dim1>

FTensor::Tensor2< T *, Tensor_Dim0, Tensor_Dim1 >::Tensor2	(	T *	d00,
		T *	d01,
		T *	d02,
		T *	d10,
		T *	d11,
		T *	d12,
		T *	d20,
		T *	d21,
		T *	d22,
		const int	i
	)

inline

Definition at line 26 of file Tensor2_pointer.hpp.

      : inc(i) {
    Tensor2_constructor<T *restrict, Tensor_Dim0, Tensor_Dim1, column_major>(
        data, d00, d01, d02, d10, d11, d12, d20, d21, d22);
  }

◆ Tensor2() [4/10]

template<class T , int Tensor_Dim0, int Tensor_Dim1>

FTensor::Tensor2< T *, Tensor_Dim0, Tensor_Dim1 >::Tensor2	(	T *	d00,
		T *	d01,
		T *	d02,
		T *	d03,
		T *	d10,
		T *	d11,
		T *	d12,
		T *	d13,
		T *	d20,
		T *	d21,
		T *	d22,
		T *	d23,
		T *	d30,
		T *	d31,
		T *	d32,
		T *	d33,
		const int	i
	)

inline

Definition at line 32 of file Tensor2_pointer.hpp.

      : inc(i) {
    Tensor2_constructor<T *restrict, Tensor_Dim0, Tensor_Dim1, column_major>(
        data, d00, d01, d02, d03, d10, d11, d12, d13, d20, d21, d22, d23, d30,
        d31, d32, d33);
  }

◆ Tensor2() [5/10]

template<class T , int Tensor_Dim0, int Tensor_Dim1>

template<class... U>

FTensor::Tensor2< T *, Tensor_Dim0, Tensor_Dim1 >::Tensor2 ( U *... d )

inline

Definition at line 42 of file Tensor2_pointer.hpp.

42: data{d...}, inc(1) {}

FTensor::d

const Tensor1_Expr< const dTensor0< T, Dim, i >, typename promote< T, double >::V, Dim, i > d(const Tensor0< T * > &a, const Index< i, Dim > index, const Tensor1< int, Dim > &d_ijk, const Tensor1< double, Dim > &d_xyz)

Definition dTensor0.hpp:27

◆ Tensor2() [6/10]

template<class T , int Tensor_Dim0, int Tensor_Dim1>

template<class U >

FTensor::Tensor2< T *, Tensor_Dim0, Tensor_Dim1 >::Tensor2	(	std::array< U , Tensor_Dim0 Tensor_Dim1 > &	a,
		const int	i = `1`
	)

inline

Definition at line 45 of file Tensor2_pointer.hpp.

      : inc(i) {
    int k = 0;
    for (int i = 0; i != Tensor_Dim0; ++i) {
      for (int j = 0; j != Tensor_Dim1; ++j, ++k) {
        data[i][j] = a[k];
      }
    }
  }

◆ Tensor2() [7/10]

template<class T , int Tensor_Dim0, int Tensor_Dim1>

FTensor::Tensor2< T *, Tensor_Dim0, Tensor_Dim1 >::Tensor2 ( )

inline

Definition at line 55 of file Tensor2_pointer.hpp.

55{}

◆ Tensor2() [8/10]

template<class T , int Tensor_Dim0, int Tensor_Dim1>

FTensor::Tensor2< T *, Tensor_Dim0, Tensor_Dim1 >::Tensor2 ( const int i = 1 )

inline

Definition at line 57 of file Tensor2_pointer.hpp.

57: inc(i) {}

◆ Tensor2() [9/10]

template<class T , int Tensor_Dim0, int Tensor_Dim1>

template<int I>

FTensor::Tensor2< T *, Tensor_Dim0, Tensor_Dim1 >::Tensor2 ( const Tensor2< PackPtr< T *, I >, Tensor_Dim0, Tensor_Dim1 > & )

privatedelete

Preventing casting on derived class.

That can be source of errors

◆ Tensor2() [10/10]

template<class T , int Tensor_Dim0, int Tensor_Dim1>

template<int G>

FTensor::Tensor2< T *, Tensor_Dim0, Tensor_Dim1 >::Tensor2 ( const Tensor2< CursorPtr< T *, G >, Tensor_Dim0, Tensor_Dim1 > & )

privatedelete

Member Function Documentation

◆ internal_contract() [1/2]

template<class T , int Tensor_Dim0, int Tensor_Dim1>

T FTensor::Tensor2< T *, Tensor_Dim0, Tensor_Dim1 >::internal_contract ( Number< 1 > ) const

inlineprivate

Definition at line 195 of file Tensor2_pointer.hpp.

195{ return *data[0][0]; }

◆ internal_contract() [2/2]

template<class T , int Tensor_Dim0, int Tensor_Dim1>

template<int N>

T FTensor::Tensor2< T *, Tensor_Dim0, Tensor_Dim1 >::internal_contract ( Number< N > ) const

inlineprivate

Definition at line 191 of file Tensor2_pointer.hpp.

                                                        {
    return *data[N - 1][N - 1] + internal_contract(Number<N - 1>());
  }

◆ operator()() [1/10]

template<class T , int Tensor_Dim0, int Tensor_Dim1>

template<char i, int Dim>

T FTensor::Tensor2< T *, Tensor_Dim0, Tensor_Dim1 >::operator()	(	const Index< i, Dim >	,
		const Index< i, Dim >	index2
	)

inline

Definition at line 181 of file Tensor2_pointer.hpp.

                                                                {
    return internal_contract(Number<Dim>());
  }

◆ operator()() [2/10]

template<class T , int Tensor_Dim0, int Tensor_Dim1>

template<char i, int Dim>

T FTensor::Tensor2< T *, Tensor_Dim0, Tensor_Dim1 >::operator()	(	const Index< i, Dim >	,
		const Index< i, Dim >	index2
	)		const

inline

Definition at line 186 of file Tensor2_pointer.hpp.

                                                                      {
    return internal_contract(Number<Dim>());
  }

◆ operator()() [3/10]

template<class T , int Tensor_Dim0, int Tensor_Dim1>

template<char i, int Dim, int N>

Tensor1_Expr< Tensor2_number_rhs_1< Tensor2< T , Tensor_Dim0, Tensor_Dim1 >, T, N >, T, Dim, i > FTensor::Tensor2< T , Tensor_Dim0, Tensor_Dim1 >::operator()	(	const Index< i, Dim >	,
		const Number< N >
	)

inline

Definition at line 129 of file Tensor2_pointer.hpp.

                                                   {
    using TensorExpr =
        Tensor2_number_rhs_1<Tensor2<T *, Tensor_Dim0, Tensor_Dim1>, T, N>;
    return Tensor1_Expr<TensorExpr, T, Dim, i>(*this);
  }

◆ operator()() [4/10]

template<class T , int Tensor_Dim0, int Tensor_Dim1>

template<char i, int Dim, int N>

Tensor1_Expr< const Tensor2_number_1< const Tensor2< T , Tensor_Dim0, Tensor_Dim1 >, T, N >, T, Dim, i > FTensor::Tensor2< T , Tensor_Dim0, Tensor_Dim1 >::operator()	(	const Index< i, Dim >	,
		const Number< N >
	)		const

inline

Definition at line 149 of file Tensor2_pointer.hpp.

                                                         {
    using TensorExpr =
        Tensor2_number_1<const Tensor2<T *, Tensor_Dim0, Tensor_Dim1>, T, N>;
    return Tensor1_Expr<TensorExpr, T, Dim, i>(TensorExpr(*this));
  }

◆ operator()() [5/10]

template<class T , int Tensor_Dim0, int Tensor_Dim1>

template<char i, char j, int Dim0, int Dim1>

Tensor2_Expr< const Tensor2< T , Tensor_Dim0, Tensor_Dim1 >, T, Dim0, Dim1, i, j > FTensor::Tensor2< T , Tensor_Dim0, Tensor_Dim1 >::operator()	(	const Index< i, Dim0 >	,
		const Index< j, Dim1 >	index2
	)		const

inline

Definition at line 113 of file Tensor2_pointer.hpp.

                                                                      {
    return Tensor2_Expr<const Tensor2<T *, Tensor_Dim0, Tensor_Dim1>, T, Dim0,
                        Dim1, i, j>(*this);
  }

◆ operator()() [6/10]

template<class T , int Tensor_Dim0, int Tensor_Dim1>

template<char i, char j, int Dim0, int Dim1>

Tensor2_Expr< Tensor2< T , Tensor_Dim0, Tensor_Dim1 >, T, Dim0, Dim1, i, j > FTensor::Tensor2< T , Tensor_Dim0, Tensor_Dim1 >::operator()	(	const Index< i, Dim0 >	,
		const Index< j, Dim1 >
	)

inline

Definition at line 105 of file Tensor2_pointer.hpp.

                                                         {
    return Tensor2_Expr<Tensor2<T *, Tensor_Dim0, Tensor_Dim1>, T, Dim0, Dim1,
                        i, j>(*this);
  }

◆ operator()() [7/10]

template<class T , int Tensor_Dim0, int Tensor_Dim1>

T & FTensor::Tensor2< T *, Tensor_Dim0, Tensor_Dim1 >::operator()	(	const int	N1,
		const int	N2
	)

inline

Definition at line 62 of file Tensor2_pointer.hpp.

                                            {
#ifdef FTENSOR_DEBUG
    if (N1 >= Tensor_Dim0 || N1 < 0 || N2 >= Tensor_Dim1 || N2 < 0) {
      std::stringstream s;
      s << "Bad index in Tensor2<T*," << Tensor_Dim0 << "," << Tensor_Dim1
        << ">.operator(" << N1 << "," << N2 << ")" << std::endl;
      throw std::out_of_range(s.str());
    }
#endif
    return *data[N1][N2];
  }

◆ operator()() [8/10]

template<class T , int Tensor_Dim0, int Tensor_Dim1>

T FTensor::Tensor2< T *, Tensor_Dim0, Tensor_Dim1 >::operator()	(	const int	N1,
		const int	N2
	)		const

inline

Definition at line 74 of file Tensor2_pointer.hpp.

                                                 {
#ifdef FTENSOR_DEBUG
    if (N1 >= Tensor_Dim0 || N1 < 0 || N2 >= Tensor_Dim1 || N2 < 0) {
      std::stringstream s;
      s << "Bad index in Tensor2<T*," << Tensor_Dim0 << "," << Tensor_Dim1
        << ">.operator(" << N1 << "," << N2 << ") const" << std::endl;
      throw std::out_of_range(s.str());
    }
#endif
    return *data[N1][N2];
  }

◆ operator()() [9/10]

template<class T , int Tensor_Dim0, int Tensor_Dim1>

template<char i, int Dim, int N>

Tensor1_Expr< Tensor2_number_rhs_0< Tensor2< T , Tensor_Dim0, Tensor_Dim1 >, T, N >, T, Dim, i > FTensor::Tensor2< T , Tensor_Dim0, Tensor_Dim1 >::operator()	(	const Number< N >	,
		const Index< i, Dim >
	)

inline

Definition at line 139 of file Tensor2_pointer.hpp.

                                                   {
    using TensorExpr =
        Tensor2_number_rhs_0<Tensor2<T *, Tensor_Dim0, Tensor_Dim1>, T, N>;
    return Tensor1_Expr<TensorExpr, T, Dim, i>(*this);
  }

◆ operator()() [10/10]

template<class T , int Tensor_Dim0, int Tensor_Dim1>

template<char i, int Dim, int N>

Tensor1_Expr< const Tensor2_number_0< const Tensor2< T , Tensor_Dim0, Tensor_Dim1 >, T, N >, T, Dim, i > FTensor::Tensor2< T , Tensor_Dim0, Tensor_Dim1 >::operator()	(	const Number< N >	,
		const Index< i, Dim >
	)		const

inline

Definition at line 159 of file Tensor2_pointer.hpp.

                                                         {
    using TensorExpr =
        Tensor2_number_0<const Tensor2<T *, Tensor_Dim0, Tensor_Dim1>, T, N>;
    return Tensor1_Expr<TensorExpr, T, Dim, i>(TensorExpr(*this));
  }

◆ operator++()

template<class T , int Tensor_Dim0, int Tensor_Dim1>

const Tensor2 & FTensor::Tensor2< T *, Tensor_Dim0, Tensor_Dim1 >::operator++ ( ) const

inline

Definition at line 168 of file Tensor2_pointer.hpp.

                                    {
    for (int i = 0; i < Tensor_Dim0; ++i)
      for (int j = 0; j < Tensor_Dim1; ++j)
        data[i][j] += inc;
    return *this;
  }

◆ ptr()

template<class T , int Tensor_Dim0, int Tensor_Dim1>

T * FTensor::Tensor2< T *, Tensor_Dim0, Tensor_Dim1 >::ptr	(	const int	N1,
		const int	N2
	)		const

inline

Definition at line 86 of file Tensor2_pointer.hpp.

                                           {
#ifdef FTENSOR_DEBUG
    if (N1 >= Tensor_Dim0 || N1 < 0 || N2 >= Tensor_Dim1 || N2 < 0) {
      std::stringstream s;
      s << "Bad index in Tensor2<T*," << Tensor_Dim0 << "," << Tensor_Dim1
        << ">.ptr(" << N1 << "," << N2 << ")" << std::endl;
      throw std::out_of_range(s.str());
    }
#endif
    return data[N1][N2];
  }

Member Data Documentation

◆ data

template<class T , int Tensor_Dim0, int Tensor_Dim1>

T* restrict FTensor::Tensor2< T *, Tensor_Dim0, Tensor_Dim1 >::data[Tensor_Dim0][Tensor_Dim1]

mutableprotected

Definition at line 11 of file Tensor2_pointer.hpp.

◆ inc

template<class T , int Tensor_Dim0, int Tensor_Dim1>

const int FTensor::Tensor2< T *, Tensor_Dim0, Tensor_Dim1 >::inc

protected

Definition at line 12 of file Tensor2_pointer.hpp.

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

src/ftensor/src/FTensor/Tensor2/Tensor2_pointer.hpp

Public Member Functions

Protected Attributes

Private Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ Tensor2() [1/10]

◆ Tensor2() [2/10]

◆ Tensor2() [3/10]

◆ Tensor2() [4/10]

◆ Tensor2() [5/10]

◆ Tensor2() [6/10]

◆ Tensor2() [7/10]

◆ Tensor2() [8/10]

◆ Tensor2() [9/10]

◆ Tensor2() [10/10]

Member Function Documentation

◆ internal_contract() [1/2]

◆ internal_contract() [2/2]

◆ operator()() [1/10]

◆ operator()() [2/10]

◆ operator()() [3/10]

◆ operator()() [4/10]

◆ operator()() [5/10]

◆ operator()() [6/10]

◆ operator()() [7/10]

◆ operator()() [8/10]

◆ operator()() [9/10]

◆ operator()() [10/10]

◆ operator++()

◆ ptr()

Member Data Documentation

◆ data

◆ inc