portelli/Grid
1
0
Fork 0
mirror of https://github.com/paboyle/Grid.git synced 2025-04-27 22:25:56 +01:00
Code Releases Activity

Namespace, indent

Browse Source
This commit is contained in:
paboyle 2018-01-14 23:59:23 +00:00
parent 31cbbfc07e
commit e9ef7e3852
1 changed files with 107 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

104
lib/lattice/Lattice_overload.h
View File

@ -1,4 +1,4 @@
/************************************************************************************* /*************************************************************************************
Grid physics library, www.github.com/paboyle/Grid Grid physics library, www.github.com/paboyle/Grid
@ -23,55 +23,55 @@ Author: Peter Boyle <paboyle@ph.ed.ac.uk>
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
See the full license in the file "LICENSE" in the top level distribution directory See the full license in the file "LICENSE" in the top level distribution directory
*************************************************************************************/ *************************************************************************************/
/* END LEGAL */ /* END LEGAL */
#ifndef GRID_LATTICE_OVERLOAD_H #ifndef GRID_LATTICE_OVERLOAD_H
#define GRID_LATTICE_OVERLOAD_H #define GRID_LATTICE_OVERLOAD_H
namespace Grid { NAMESPACE_BEGIN(Grid);
////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////
// unary negation // unary negation
////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////
template<class vobj> template<class vobj>
inline Lattice<vobj> operator -(const Lattice<vobj> &r) inline Lattice<vobj> operator -(const Lattice<vobj> &r)
{ {
Lattice<vobj> ret(r._grid); Lattice<vobj> ret(r._grid);
parallel_for(int ss=0;ss<r._grid->oSites();ss++){ parallel_for(int ss=0;ss<r._grid->oSites();ss++){
vstream(ret._odata[ss], -r._odata[ss]); vstream(ret._odata[ss], -r._odata[ss]);
} }
return ret; return ret;
} }
///////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////
// Lattice BinOp Lattice, // Lattice BinOp Lattice,
//NB mult performs conformable check. Do not reapply here for performance. //NB mult performs conformable check. Do not reapply here for performance.
///////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////
template<class left,class right> template<class left,class right>
inline auto operator * (const Lattice<left> &lhs,const Lattice<right> &rhs)-> Lattice<decltype(lhs._odata[0]*rhs._odata[0])> inline auto operator * (const Lattice<left> &lhs,const Lattice<right> &rhs)-> Lattice<decltype(lhs._odata[0]*rhs._odata[0])>
{ {
Lattice<decltype(lhs._odata[0]*rhs._odata[0])> ret(rhs._grid); Lattice<decltype(lhs._odata[0]*rhs._odata[0])> ret(rhs._grid);
mult(ret,lhs,rhs); mult(ret,lhs,rhs);
return ret; return ret;
} }
template<class left,class right> template<class left,class right>
inline auto operator + (const Lattice<left> &lhs,const Lattice<right> &rhs)-> Lattice<decltype(lhs._odata[0]+rhs._odata[0])> inline auto operator + (const Lattice<left> &lhs,const Lattice<right> &rhs)-> Lattice<decltype(lhs._odata[0]+rhs._odata[0])>
{ {
Lattice<decltype(lhs._odata[0]+rhs._odata[0])> ret(rhs._grid); Lattice<decltype(lhs._odata[0]+rhs._odata[0])> ret(rhs._grid);
add(ret,lhs,rhs); add(ret,lhs,rhs);
return ret; return ret;
} }
template<class left,class right> template<class left,class right>
inline auto operator - (const Lattice<left> &lhs,const Lattice<right> &rhs)-> Lattice<decltype(lhs._odata[0]-rhs._odata[0])> inline auto operator - (const Lattice<left> &lhs,const Lattice<right> &rhs)-> Lattice<decltype(lhs._odata[0]-rhs._odata[0])>
{ {
Lattice<decltype(lhs._odata[0]-rhs._odata[0])> ret(rhs._grid); Lattice<decltype(lhs._odata[0]-rhs._odata[0])> ret(rhs._grid);
sub(ret,lhs,rhs); sub(ret,lhs,rhs);
return ret; return ret;
} }
// Scalar BinOp Lattice ;generate return type // Scalar BinOp Lattice ;generate return type
template<class left,class right> template<class left,class right>
inline auto operator * (const left &lhs,const Lattice<right> &rhs) -> Lattice<decltype(lhs*rhs._odata[0])> inline auto operator * (const left &lhs,const Lattice<right> &rhs) -> Lattice<decltype(lhs*rhs._odata[0])>
{ {
Lattice<decltype(lhs*rhs._odata[0])> ret(rhs._grid); Lattice<decltype(lhs*rhs._odata[0])> ret(rhs._grid);
parallel_for(int ss=0;ss<rhs._grid->oSites(); ss++){ parallel_for(int ss=0;ss<rhs._grid->oSites(); ss++){
decltype(lhs*rhs._odata[0]) tmp=lhs*rhs._odata[ss]; decltype(lhs*rhs._odata[0]) tmp=lhs*rhs._odata[ss];
@ -79,10 +79,10 @@ namespace Grid {
// ret._odata[ss]=lhs*rhs._odata[ss]; // ret._odata[ss]=lhs*rhs._odata[ss];
} }
return ret; return ret;
} }
template<class left,class right> template<class left,class right>
inline auto operator + (const left &lhs,const Lattice<right> &rhs) -> Lattice<decltype(lhs+rhs._odata[0])> inline auto operator + (const left &lhs,const Lattice<right> &rhs) -> Lattice<decltype(lhs+rhs._odata[0])>
{ {
Lattice<decltype(lhs+rhs._odata[0])> ret(rhs._grid); Lattice<decltype(lhs+rhs._odata[0])> ret(rhs._grid);
parallel_for(int ss=0;ss<rhs._grid->oSites(); ss++){ parallel_for(int ss=0;ss<rhs._grid->oSites(); ss++){
decltype(lhs+rhs._odata[0]) tmp =lhs-rhs._odata[ss]; decltype(lhs+rhs._odata[0]) tmp =lhs-rhs._odata[ss];
@ -90,20 +90,20 @@ namespace Grid {
// ret._odata[ss]=lhs+rhs._odata[ss]; // ret._odata[ss]=lhs+rhs._odata[ss];
} }
return ret; return ret;
} }
template<class left,class right> template<class left,class right>
inline auto operator - (const left &lhs,const Lattice<right> &rhs) -> Lattice<decltype(lhs-rhs._odata[0])> inline auto operator - (const left &lhs,const Lattice<right> &rhs) -> Lattice<decltype(lhs-rhs._odata[0])>
{ {
Lattice<decltype(lhs-rhs._odata[0])> ret(rhs._grid); Lattice<decltype(lhs-rhs._odata[0])> ret(rhs._grid);
parallel_for(int ss=0;ss<rhs._grid->oSites(); ss++){ parallel_for(int ss=0;ss<rhs._grid->oSites(); ss++){
decltype(lhs-rhs._odata[0]) tmp=lhs-rhs._odata[ss]; decltype(lhs-rhs._odata[0]) tmp=lhs-rhs._odata[ss];
vstream(ret._odata[ss],tmp); vstream(ret._odata[ss],tmp);
} }
return ret; return ret;
} }
template<class left,class right> template<class left,class right>
inline auto operator * (const Lattice<left> &lhs,const right &rhs) -> Lattice<decltype(lhs._odata[0]*rhs)> inline auto operator * (const Lattice<left> &lhs,const right &rhs) -> Lattice<decltype(lhs._odata[0]*rhs)>
{ {
Lattice<decltype(lhs._odata[0]*rhs)> ret(lhs._grid); Lattice<decltype(lhs._odata[0]*rhs)> ret(lhs._grid);
parallel_for(int ss=0;ss<lhs._grid->oSites(); ss++){ parallel_for(int ss=0;ss<lhs._grid->oSites(); ss++){
decltype(lhs._odata[0]*rhs) tmp =lhs._odata[ss]*rhs; decltype(lhs._odata[0]*rhs) tmp =lhs._odata[ss]*rhs;
@ -111,10 +111,10 @@ namespace Grid {
// ret._odata[ss]=lhs._odata[ss]*rhs; // ret._odata[ss]=lhs._odata[ss]*rhs;
} }
return ret; return ret;
} }
template<class left,class right> template<class left,class right>
inline auto operator + (const Lattice<left> &lhs,const right &rhs) -> Lattice<decltype(lhs._odata[0]+rhs)> inline auto operator + (const Lattice<left> &lhs,const right &rhs) -> Lattice<decltype(lhs._odata[0]+rhs)>
{ {
Lattice<decltype(lhs._odata[0]+rhs)> ret(lhs._grid); Lattice<decltype(lhs._odata[0]+rhs)> ret(lhs._grid);
parallel_for(int ss=0;ss<rhs._grid->oSites(); ss++){ parallel_for(int ss=0;ss<rhs._grid->oSites(); ss++){
decltype(lhs._odata[0]+rhs) tmp=lhs._odata[ss]+rhs; decltype(lhs._odata[0]+rhs) tmp=lhs._odata[ss]+rhs;
@ -122,10 +122,10 @@ namespace Grid {
// ret._odata[ss]=lhs._odata[ss]+rhs; // ret._odata[ss]=lhs._odata[ss]+rhs;
} }
return ret; return ret;
} }
template<class left,class right> template<class left,class right>
inline auto operator - (const Lattice<left> &lhs,const right &rhs) -> Lattice<decltype(lhs._odata[0]-rhs)> inline auto operator - (const Lattice<left> &lhs,const right &rhs) -> Lattice<decltype(lhs._odata[0]-rhs)>
{ {
Lattice<decltype(lhs._odata[0]-rhs)> ret(lhs._grid); Lattice<decltype(lhs._odata[0]-rhs)> ret(lhs._grid);
parallel_for(int ss=0;ss<rhs._grid->oSites(); ss++){ parallel_for(int ss=0;ss<rhs._grid->oSites(); ss++){
decltype(lhs._odata[0]-rhs) tmp=lhs._odata[ss]-rhs; decltype(lhs._odata[0]-rhs) tmp=lhs._odata[ss]-rhs;
@ -133,6 +133,6 @@ namespace Grid {
// ret._odata[ss]=lhs._odata[ss]-rhs; // ret._odata[ss]=lhs._odata[ss]-rhs;
} }
return ret; return ret;
}
} }
NAMESPACE_END(Grid);
#endif #endif