v0.16.0
Loading...
Searching...
No Matches
Public Member Functions | Private Attributes | List of all members
FTensor::Tensor2_Expr< Tensor2< A, Tensor_Dim0, Tensor_Dim1 >, T, Dim0, Dim1, i, j > Class Template Reference

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

Collaboration diagram for FTensor::Tensor2_Expr< Tensor2< A, Tensor_Dim0, Tensor_Dim1 >, T, Dim0, Dim1, i, j >:
[legend]

Public Member Functions

 Tensor2_Expr (Tensor2< A, Tensor_Dim0, Tensor_Dim1 > &a)
 
 Tensor2_Expr (const Tensor2_Expr &)=default
 
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<class B , class U , int Dim1_0, int Dim1_1, char i_1, char j_1>
auto & equals (const Tensor2_Expr< B, U, Dim1_0, Dim1_1, i_1, j_1 > &rhs)
 
template<class B , class U , int Dim1_0, int Dim1_1, char i_1, char j_1>
auto & operator= (const FTensor::Tensor2_Expr< B, U, Dim1_0, Dim1_1, i_1, j_1 > &rhs)
 
auto & operator= (const Tensor2_Expr< Tensor2< A, Tensor_Dim0, Tensor_Dim1 >, T, Dim0, Dim1, i, j > &rhs)
 
template<class B , class U , int Dim, char i_1, char j_1>
auto & equals (const Tensor2_symmetric_Expr< B, U, Dim, i_1, j_1 > &rhs)
 
template<class B , class U , int Dim, char i_1, char j_1>
auto & operator= (const Tensor2_symmetric_Expr< B, U, Dim, i_1, j_1 > &rhs)
 
template<class B , class U , int Dim1_0, int Dim1_1, char i_1, char j_1>
auto & operator+= (const Tensor2_Expr< B, U, Dim1_0, Dim1_1, i_1, j_1 > &rhs)
 
template<class B , class U , int Dim1_0, int Dim1_1, char i_1, char j_1>
auto & operator-= (const Tensor2_Expr< B, U, Dim1_0, Dim1_1, i_1, j_1 > &rhs)
 
template<class B , class U , int Dim, char i_1, char j_1>
auto & operator+= (const Tensor2_symmetric_Expr< B, U, Dim, i_1, j_1 > &rhs)
 
template<class B , class U , int Dim, char i_1, char j_1>
auto & operator-= (const Tensor2_symmetric_Expr< B, U, Dim, i_1, j_1 > &rhs)
 
template<class U >
auto & operator= (const U &u)
 
template<class U >
auto & operator+= (const U &u)
 
template<class U >
auto & operator-= (const U &u)
 
template<class U >
auto & operator*= (const U &u)
 
template<class U >
auto & operator/= (const U &u)
 
template<class B , class U , int Dim1_0, int Dim1_1, char i_1, char j_1>
auto & operator<<= (const Tensor2_Expr< B, U, Dim1_0, Dim1_1, i_1, j_1 > &rhs)
 
template<class B , class U , int Dim1_0, int Dim1_1, char i_1, char j_1>
auto & operator>>= (const Tensor2_Expr< B, U, Dim1_0, Dim1_1, i_1, j_1 > &rhs)
 

Private Attributes

Tensor2< A, Tensor_Dim0, Tensor_Dim1 > & iter
 

Detailed Description

template<class A, class T, int Tensor_Dim0, int Tensor_Dim1, int Dim0, int Dim1, char i, char j>
class FTensor::Tensor2_Expr< Tensor2< A, Tensor_Dim0, Tensor_Dim1 >, T, Dim0, Dim1, i, j >

Definition at line 38 of file Tensor2_Expr.hpp.

Constructor & Destructor Documentation

◆ Tensor2_Expr() [1/2]

template<class A , class T , int Tensor_Dim0, int Tensor_Dim1, int Dim0, int Dim1, char i, char j>
FTensor::Tensor2_Expr< Tensor2< A, Tensor_Dim0, Tensor_Dim1 >, T, Dim0, Dim1, i, j >::Tensor2_Expr ( Tensor2< A, Tensor_Dim0, Tensor_Dim1 > &  a)
inline

Definition at line 43 of file Tensor2_Expr.hpp.

43: iter(a) {}
a
constexpr double a
Definition approx_sphere.cpp:30
FTensor::Tensor2_Expr< Tensor2< A, Tensor_Dim0, Tensor_Dim1 >, T, Dim0, Dim1, i, j >::iter
Tensor2< A, Tensor_Dim0, Tensor_Dim1 > & iter
Definition Tensor2_Expr.hpp:40

◆ Tensor2_Expr() [2/2]

template<class A , class T , int Tensor_Dim0, int Tensor_Dim1, int Dim0, int Dim1, char i, char j>
FTensor::Tensor2_Expr< Tensor2< A, Tensor_Dim0, Tensor_Dim1 >, T, Dim0, Dim1, i, j >::Tensor2_Expr ( const Tensor2_Expr< Tensor2< A, Tensor_Dim0, Tensor_Dim1 >, T, Dim0, Dim1, i, j > &  )
default

Member Function Documentation

◆ equals() [1/2]

template<class A , class T , int Tensor_Dim0, int Tensor_Dim1, int Dim0, int Dim1, char i, char j>
template<class B , class U , int Dim1_0, int Dim1_1, char i_1, char j_1>
auto & FTensor::Tensor2_Expr< Tensor2< A, Tensor_Dim0, Tensor_Dim1 >, T, Dim0, Dim1, i, j >::equals ( const Tensor2_Expr< B, U, Dim1_0, Dim1_1, i_1, j_1 > &  rhs)
inline

Definition at line 54 of file Tensor2_Expr.hpp.

55 {
56 for(int ii = 0; ii < Dim0; ++ii)
57 for(int jj = 0; jj < Dim1; ++jj)
58 {
59 iter(ii, jj) = permute(*this, rhs, ii, jj);
60 }
61 return *this;
62 }
FTensor::permute
U permute(const Tensor2_Expr< A, T, Dim0_0, Dim0_1, i0, j0 > &, const Tensor2_Expr< B, U, Dim1_0, Dim1_1, i1, j1 > &rhs, const int N0, const int N1)
Definition permute.hpp:11

◆ equals() [2/2]

template<class A , class T , int Tensor_Dim0, int Tensor_Dim1, int Dim0, int Dim1, char i, char j>
template<class B , class U , int Dim, char i_1, char j_1>
auto & FTensor::Tensor2_Expr< Tensor2< A, Tensor_Dim0, Tensor_Dim1 >, T, Dim0, Dim1, i, j >::equals ( const Tensor2_symmetric_Expr< B, U, Dim, i_1, j_1 > &  rhs)
inline

Definition at line 78 of file Tensor2_Expr.hpp.

78 {
79 for (int ii = 0; ii != Dim; ++ii)
80 for (int jj = 0; jj != Dim; ++jj) {
81 iter(ii, jj) = rhs(ii, jj);
82 }
83 return *this;
84 }

◆ operator()() [1/2]

template<class A , class T , int Tensor_Dim0, int Tensor_Dim1, int Dim0, int Dim1, char i, char j>
T & FTensor::Tensor2_Expr< Tensor2< A, Tensor_Dim0, Tensor_Dim1 >, T, Dim0, Dim1, i, j >::operator() ( const int  N1,
const int  N2 
)
inline

Definition at line 45 of file Tensor2_Expr.hpp.

45{ return iter(N1, N2); }

◆ operator()() [2/2]

template<class A , class T , int Tensor_Dim0, int Tensor_Dim1, int Dim0, int Dim1, char i, char j>
T FTensor::Tensor2_Expr< Tensor2< A, Tensor_Dim0, Tensor_Dim1 >, T, Dim0, Dim1, i, j >::operator() ( const int  N1,
const int  N2 
) const
inline

Definition at line 46 of file Tensor2_Expr.hpp.

46{ return iter(N1, N2); }

◆ operator*=()

template<class A , class T , int Tensor_Dim0, int Tensor_Dim1, int Dim0, int Dim1, char i, char j>
template<class U >
auto & FTensor::Tensor2_Expr< Tensor2< A, Tensor_Dim0, Tensor_Dim1 >, T, Dim0, Dim1, i, j >::operator*= ( const U &  u)
inline

Definition at line 163 of file Tensor2_Expr.hpp.

164 {
165 for(int ii = 0; ii < Dim0; ++ii)
166 for(int jj = 0; jj < Dim1; ++jj)
167 {
168 iter(ii, jj) *= u;
169 }
170 return *this;
171 }

◆ operator+=() [1/3]

template<class A , class T , int Tensor_Dim0, int Tensor_Dim1, int Dim0, int Dim1, char i, char j>
template<class B , class U , int Dim1_0, int Dim1_1, char i_1, char j_1>
auto & FTensor::Tensor2_Expr< Tensor2< A, Tensor_Dim0, Tensor_Dim1 >, T, Dim0, Dim1, i, j >::operator+= ( const Tensor2_Expr< B, U, Dim1_0, Dim1_1, i_1, j_1 > &  rhs)
inline

Definition at line 92 of file Tensor2_Expr.hpp.

93 {
94 for(int ii = 0; ii < Dim0; ++ii)
95 for(int jj = 0; jj < Dim1; ++jj)
96 {
97 iter(ii, jj) += permute(*this, rhs, ii, jj);
98 }
99 return *this;
100 }

◆ operator+=() [2/3]

template<class A , class T , int Tensor_Dim0, int Tensor_Dim1, int Dim0, int Dim1, char i, char j>
template<class B , class U , int Dim, char i_1, char j_1>
auto & FTensor::Tensor2_Expr< Tensor2< A, Tensor_Dim0, Tensor_Dim1 >, T, Dim0, Dim1, i, j >::operator+= ( const Tensor2_symmetric_Expr< B, U, Dim, i_1, j_1 > &  rhs)
inline

Definition at line 114 of file Tensor2_Expr.hpp.

114 {
115 for (int ii = 0; ii != Dim; ++ii)
116 for (int jj = 0; jj != Dim; ++jj) {
117 iter(ii, jj) += rhs(ii, jj);
118 }
119 return *this;
120 }

◆ operator+=() [3/3]

template<class A , class T , int Tensor_Dim0, int Tensor_Dim1, int Dim0, int Dim1, char i, char j>
template<class U >
auto & FTensor::Tensor2_Expr< Tensor2< A, Tensor_Dim0, Tensor_Dim1 >, T, Dim0, Dim1, i, j >::operator+= ( const U &  u)
inline

Definition at line 143 of file Tensor2_Expr.hpp.

144 {
145 for(int ii = 0; ii < Dim0; ++ii)
146 for(int jj = 0; jj < Dim1; ++jj)
147 {
148 iter(ii, jj) += u;
149 }
150 return *this;
151 }

◆ operator-=() [1/3]

template<class A , class T , int Tensor_Dim0, int Tensor_Dim1, int Dim0, int Dim1, char i, char j>
template<class B , class U , int Dim1_0, int Dim1_1, char i_1, char j_1>
auto & FTensor::Tensor2_Expr< Tensor2< A, Tensor_Dim0, Tensor_Dim1 >, T, Dim0, Dim1, i, j >::operator-= ( const Tensor2_Expr< B, U, Dim1_0, Dim1_1, i_1, j_1 > &  rhs)
inline

Definition at line 103 of file Tensor2_Expr.hpp.

104 {
105 for(int ii = 0; ii < Dim0; ++ii)
106 for(int jj = 0; jj < Dim1; ++jj)
107 {
108 iter(ii, jj) -= permute(*this, rhs, ii, jj);
109 }
110 return *this;
111 }

◆ operator-=() [2/3]

template<class A , class T , int Tensor_Dim0, int Tensor_Dim1, int Dim0, int Dim1, char i, char j>
template<class B , class U , int Dim, char i_1, char j_1>
auto & FTensor::Tensor2_Expr< Tensor2< A, Tensor_Dim0, Tensor_Dim1 >, T, Dim0, Dim1, i, j >::operator-= ( const Tensor2_symmetric_Expr< B, U, Dim, i_1, j_1 > &  rhs)
inline

Definition at line 123 of file Tensor2_Expr.hpp.

123 {
124 for (int ii = 0; ii != Dim; ++ii)
125 for (int jj = 0; jj != Dim; ++jj) {
126 iter(ii, jj) -= rhs(ii, jj);
127 }
128 return *this;
129 }

◆ operator-=() [3/3]

template<class A , class T , int Tensor_Dim0, int Tensor_Dim1, int Dim0, int Dim1, char i, char j>
template<class U >
auto & FTensor::Tensor2_Expr< Tensor2< A, Tensor_Dim0, Tensor_Dim1 >, T, Dim0, Dim1, i, j >::operator-= ( const U &  u)
inline

Definition at line 153 of file Tensor2_Expr.hpp.

154 {
155 for(int ii = 0; ii < Dim0; ++ii)
156 for(int jj = 0; jj < Dim1; ++jj)
157 {
158 iter(ii, jj) -= u;
159 }
160 return *this;
161 }

◆ operator/=()

template<class A , class T , int Tensor_Dim0, int Tensor_Dim1, int Dim0, int Dim1, char i, char j>
template<class U >
auto & FTensor::Tensor2_Expr< Tensor2< A, Tensor_Dim0, Tensor_Dim1 >, T, Dim0, Dim1, i, j >::operator/= ( const U &  u)
inline

Definition at line 173 of file Tensor2_Expr.hpp.

174 {
175 for(int ii = 0; ii < Dim0; ++ii)
176 for(int jj = 0; jj < Dim1; ++jj)
177 {
178 iter(ii, jj) /= u;
179 }
180 return *this;
181 }

◆ operator<<=()

template<class A , class T , int Tensor_Dim0, int Tensor_Dim1, int Dim0, int Dim1, char i, char j>
template<class B , class U , int Dim1_0, int Dim1_1, char i_1, char j_1>
auto & FTensor::Tensor2_Expr< Tensor2< A, Tensor_Dim0, Tensor_Dim1 >, T, Dim0, Dim1, i, j >::operator<<= ( const Tensor2_Expr< B, U, Dim1_0, Dim1_1, i_1, j_1 > &  rhs)
inline

Definition at line 186 of file Tensor2_Expr.hpp.

187 {
188 for(int ii = 0; ii < Dim0; ++ii)
189 for(int jj = 0; jj < Dim1; ++jj)
190 {
191 iter(ii, jj) <<= permute(*this, rhs, ii, jj);
192 }
193 return *this;
194 }

◆ operator=() [1/4]

template<class A , class T , int Tensor_Dim0, int Tensor_Dim1, int Dim0, int Dim1, char i, char j>
template<class B , class U , int Dim1_0, int Dim1_1, char i_1, char j_1>
auto & FTensor::Tensor2_Expr< Tensor2< A, Tensor_Dim0, Tensor_Dim1 >, T, Dim0, Dim1, i, j >::operator= ( const FTensor::Tensor2_Expr< B, U, Dim1_0, Dim1_1, i_1, j_1 > &  rhs)
inline

Definition at line 66 of file Tensor2_Expr.hpp.

67 {
68 return equals(rhs);
69 }
FTensor::Tensor2_Expr< Tensor2< A, Tensor_Dim0, Tensor_Dim1 >, T, Dim0, Dim1, i, j >::equals
auto & equals(const Tensor2_Expr< B, U, Dim1_0, Dim1_1, i_1, j_1 > &rhs)
Definition Tensor2_Expr.hpp:54

◆ operator=() [2/4]

template<class A , class T , int Tensor_Dim0, int Tensor_Dim1, int Dim0, int Dim1, char i, char j>
auto & FTensor::Tensor2_Expr< Tensor2< A, Tensor_Dim0, Tensor_Dim1 >, T, Dim0, Dim1, i, j >::operator= ( const Tensor2_Expr< Tensor2< A, Tensor_Dim0, Tensor_Dim1 >, T, Dim0, Dim1, i, j > &  rhs)
inline

Definition at line 71 of file Tensor2_Expr.hpp.

73 {
74 return equals(rhs);
75 }

◆ operator=() [3/4]

template<class A , class T , int Tensor_Dim0, int Tensor_Dim1, int Dim0, int Dim1, char i, char j>
template<class B , class U , int Dim, char i_1, char j_1>
auto & FTensor::Tensor2_Expr< Tensor2< A, Tensor_Dim0, Tensor_Dim1 >, T, Dim0, Dim1, i, j >::operator= ( const Tensor2_symmetric_Expr< B, U, Dim, i_1, j_1 > &  rhs)
inline

Definition at line 87 of file Tensor2_Expr.hpp.

87 {
88 return equals(rhs);
89 }

◆ operator=() [4/4]

template<class A , class T , int Tensor_Dim0, int Tensor_Dim1, int Dim0, int Dim1, char i, char j>
template<class U >
auto & FTensor::Tensor2_Expr< Tensor2< A, Tensor_Dim0, Tensor_Dim1 >, T, Dim0, Dim1, i, j >::operator= ( const U &  u)
inline

Definition at line 133 of file Tensor2_Expr.hpp.

134 {
135 for(int ii = 0; ii < Dim0; ++ii)
136 for(int jj = 0; jj < Dim1; ++jj)
137 {
138 iter(ii, jj) = u;
139 }
140 return *this;
141 }

◆ operator>>=()

template<class A , class T , int Tensor_Dim0, int Tensor_Dim1, int Dim0, int Dim1, char i, char j>
template<class B , class U , int Dim1_0, int Dim1_1, char i_1, char j_1>
auto & FTensor::Tensor2_Expr< Tensor2< A, Tensor_Dim0, Tensor_Dim1 >, T, Dim0, Dim1, i, j >::operator>>= ( const Tensor2_Expr< B, U, Dim1_0, Dim1_1, i_1, j_1 > &  rhs)
inline

Definition at line 197 of file Tensor2_Expr.hpp.

198 {
199 for(int ii = 0; ii < Dim0; ++ii)
200 for(int jj = 0; jj < Dim1; ++jj)
201 {
202 iter(ii, jj) >>= permute_ref(*this, rhs, ii, jj);
203 }
204 return *this;
205 }
FTensor::permute_ref
U & permute_ref(const Tensor2_Expr< A, T, Dim0_0, Dim0_1, i0, j0 > &, const Tensor2_Expr< B, U, Dim1_0, Dim1_1, i1, j1 > &rhs, const int N0, const int N1)
Definition permute.hpp:66

◆ ptr()

template<class A , class T , int Tensor_Dim0, int Tensor_Dim1, int Dim0, int Dim1, char i, char j>
T * FTensor::Tensor2_Expr< Tensor2< A, Tensor_Dim0, Tensor_Dim1 >, T, Dim0, Dim1, i, j >::ptr ( const int  N1,
const int  N2 
) const
inline

Definition at line 47 of file Tensor2_Expr.hpp.

47{ return iter.ptr(N1, N2); }
FTensor::Tensor2::ptr
T * ptr(const int N1, const int N2) const
Definition Tensor2_value.hpp:33

Member Data Documentation

◆ iter

template<class A , class T , int Tensor_Dim0, int Tensor_Dim1, int Dim0, int Dim1, char i, char j>
Tensor2<A, Tensor_Dim0, Tensor_Dim1>& FTensor::Tensor2_Expr< Tensor2< A, Tensor_Dim0, Tensor_Dim1 >, T, Dim0, Dim1, i, j >::iter
private

Definition at line 40 of file Tensor2_Expr.hpp.

The documentation for this class was generated from the following file:
Generated by Doxygen 1.9.8 and hosted at University of Glasgow