portelli/Grid
1
0
Fork 0
mirror of https://github.com/paboyle/Grid.git synced 2025-06-25 03:02:02 +01:00
Code Releases Activity

Updates after review with Peter.

Browse Source
This commit is contained in:
Michael Marshall
2019-03-07 14:30:35 +00:00
parent b7db99967a
commit 91cffef883
3 changed files with 95 additions and 202 deletions
Download Patch File Download Diff File Expand all files Collapse all files

115
Grid/tensors/Tensor_traits.h
View File

@ -5,6 +5,7 @@
Author: Azusa Yamaguchi <ayamaguc@staffmail.ed.ac.uk>
Author: Peter Boyle <paboyle@ph.ed.ac.uk>
Author: Christopher Kelly <ckelly@phys.columbia.edu>
Author: Michael Marshall <michael.marshall@ed.ac.au>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
@ -32,14 +33,10 @@ namespace Grid {
template<class T, int N> class iMatrix;
// These are the Grid tensors
template<typename T> struct isGridTensor
: public std::false_type { static constexpr bool notvalue = true; };
template<class T> struct isGridTensor<iScalar<T>>
: public std::true_type { static constexpr bool notvalue = false; };
template<class T, int N> struct isGridTensor<iVector<T, N>>
: public std::true_type { static constexpr bool notvalue = false; };
template<class T, int N> struct isGridTensor<iMatrix<T, N>>
: public std::true_type { static constexpr bool notvalue = false; };
template<typename T> struct isGridTensor : public std::false_type { static constexpr bool notvalue = true; };
template<class T> struct isGridTensor<iScalar<T>> : public std::true_type { static constexpr bool notvalue = false; };
template<class T, int N> struct isGridTensor<iVector<T, N>> : public std::true_type { static constexpr bool notvalue = false; };
template<class T, int N> struct isGridTensor<iMatrix<T, N>> : public std::true_type { static constexpr bool notvalue = false; };
//////////////////////////////////////////////////////////////////////////////////
// Want to recurse: GridTypeMapper<Matrix<vComplexD> >::scalar_type == ComplexD.
@ -57,20 +54,15 @@ namespace Grid {
//////////////////////////////////////////////////////////////////////////////////
// This saves repeating common properties for supported Grid Scalar types
template<typename T, typename V=void> struct GridTypeMapper_Base {};
// TensorLevel How many nested grid tensors
// Rank Rank of the grid tensor
// count Total number of elements, i.e. product of dimensions
// scalar_size Size of the underlying fundamental object (tensor_reduced) in bytes
// size Total size of all elements in bytes
// Dimension(dim) Size of dimension dim
template<typename T> struct GridTypeMapper_Base<T> {
struct GridTypeMapper_Base {
static constexpr int TensorLevel = 0;
static constexpr int Rank = 0;
static constexpr std::size_t count = 1;
static constexpr std::size_t scalar_size = sizeof(T);
static constexpr std::size_t size = scalar_size * count;
static constexpr int Dimension(unsigned int dim) { return 0; }
static constexpr int Dimension(int dim) { return 0; }
};
//////////////////////////////////////////////////////////////////////////////////
@ -79,7 +71,7 @@ namespace Grid {
template<typename T> struct GridTypeMapper {};
template<> struct GridTypeMapper<RealF> : public GridTypeMapper_Base<RealF> {
template<> struct GridTypeMapper<RealF> : public GridTypeMapper_Base {
typedef RealF scalar_type;
typedef RealF vector_type;
typedef RealD vector_typeD;
@ -89,7 +81,7 @@ namespace Grid {
typedef RealF Realified;
typedef RealD DoublePrecision;
};
template<> struct GridTypeMapper<RealD> : public GridTypeMapper_Base<RealD> {
template<> struct GridTypeMapper<RealD> : public GridTypeMapper_Base {
typedef RealD scalar_type;
typedef RealD vector_type;
typedef RealD vector_typeD;
@ -99,7 +91,7 @@ namespace Grid {
typedef RealD Realified;
typedef RealD DoublePrecision;
};
template<> struct GridTypeMapper<ComplexF> : public GridTypeMapper_Base<ComplexF> {
template<> struct GridTypeMapper<ComplexF> : public GridTypeMapper_Base {
typedef ComplexF scalar_type;
typedef ComplexF vector_type;
typedef ComplexD vector_typeD;
@ -109,7 +101,7 @@ namespace Grid {
typedef RealF Realified;
typedef ComplexD DoublePrecision;
};
template<> struct GridTypeMapper<ComplexD> : public GridTypeMapper_Base<ComplexD> {
template<> struct GridTypeMapper<ComplexD> : public GridTypeMapper_Base {
typedef ComplexD scalar_type;
typedef ComplexD vector_type;
typedef ComplexD vector_typeD;
@ -119,7 +111,7 @@ namespace Grid {
typedef RealD Realified;
typedef ComplexD DoublePrecision;
};
template<> struct GridTypeMapper<Integer> : public GridTypeMapper_Base<Integer> {
template<> struct GridTypeMapper<Integer> : public GridTypeMapper_Base {
typedef Integer scalar_type;
typedef Integer vector_type;
typedef Integer vector_typeD;
@ -130,7 +122,7 @@ namespace Grid {
typedef void DoublePrecision;
};
template<> struct GridTypeMapper<vRealF> : public GridTypeMapper_Base<vRealF> {
template<> struct GridTypeMapper<vRealF> : public GridTypeMapper_Base {
typedef RealF scalar_type;
typedef vRealF vector_type;
typedef vRealD vector_typeD;
@ -140,7 +132,7 @@ namespace Grid {
typedef vRealF Realified;
typedef vRealD DoublePrecision;
};
template<> struct GridTypeMapper<vRealD> : public GridTypeMapper_Base<vRealD> {
template<> struct GridTypeMapper<vRealD> : public GridTypeMapper_Base {
typedef RealD scalar_type;
typedef vRealD vector_type;
typedef vRealD vector_typeD;
@ -150,7 +142,17 @@ namespace Grid {
typedef vRealD Realified;
typedef vRealD DoublePrecision;
};
template<> struct GridTypeMapper<vComplexH> : public GridTypeMapper_Base<vComplexH> {
template<> struct GridTypeMapper<vRealH> : public GridTypeMapper_Base {
typedef RealF scalar_type;
typedef vRealH vector_type;
typedef vRealD vector_typeD;
typedef vRealH tensor_reduced;
typedef RealF scalar_object;
typedef vComplexH Complexified;
typedef vRealH Realified;
typedef vRealD DoublePrecision;
};
template<> struct GridTypeMapper<vComplexH> : public GridTypeMapper_Base {
typedef ComplexF scalar_type;
typedef vComplexH vector_type;
typedef vComplexD vector_typeD;
@ -160,7 +162,7 @@ namespace Grid {
typedef vRealH Realified;
typedef vComplexD DoublePrecision;
};
template<> struct GridTypeMapper<vComplexF> : public GridTypeMapper_Base<vComplexF> {
template<> struct GridTypeMapper<vComplexF> : public GridTypeMapper_Base {
typedef ComplexF scalar_type;
typedef vComplexF vector_type;
typedef vComplexD vector_typeD;
@ -170,7 +172,7 @@ namespace Grid {
typedef vRealF Realified;
typedef vComplexD DoublePrecision;
};
template<> struct GridTypeMapper<vComplexD> : public GridTypeMapper_Base<vComplexD> {
template<> struct GridTypeMapper<vComplexD> : public GridTypeMapper_Base {
typedef ComplexD scalar_type;
typedef vComplexD vector_type;
typedef vComplexD vector_typeD;
@ -180,7 +182,7 @@ namespace Grid {
typedef vRealD Realified;
typedef vComplexD DoublePrecision;
};
template<> struct GridTypeMapper<vInteger> : public GridTypeMapper_Base<vInteger> {
template<> struct GridTypeMapper<vInteger> : public GridTypeMapper_Base {
typedef Integer scalar_type;
typedef vInteger vector_type;
typedef vInteger vector_typeD;
@ -192,46 +194,49 @@ namespace Grid {
};
#define GridTypeMapper_RepeatedTypes \
typedef typename ObjectTraits::scalar_type scalar_type; \
typedef typename ObjectTraits::vector_type vector_type; \
typedef typename ObjectTraits::vector_typeD vector_typeD; \
typedef typename ObjectTraits::tensor_reduced tensor_reduced; \
typedef typename ObjectTraits::scalar_object scalar_object; \
typedef typename ObjectTraits::Complexified Complexified; \
typedef typename ObjectTraits::Realified Realified; \
typedef typename ObjectTraits::DoublePrecision DoublePrecision; \
static constexpr int TensorLevel = BaseTraits::TensorLevel + 1; \
static constexpr std::size_t scalar_size = BaseTraits::scalar_size; \
static constexpr std::size_t size = scalar_size * count
using BaseTraits = GridTypeMapper<T>; \
using scalar_type = typename BaseTraits::scalar_type; \
using vector_type = typename BaseTraits::vector_type; \
using vector_typeD = typename BaseTraits::vector_typeD; \
static constexpr int TensorLevel = BaseTraits::TensorLevel + 1
template<typename T> struct GridTypeMapper<iScalar<T>> {
using ObjectTraits = iScalar<T>;
using BaseTraits = GridTypeMapper<T>;
static constexpr int Rank = 1 + BaseTraits::Rank;
static constexpr std::size_t count = 1 * BaseTraits::count;
static constexpr int Dimension(unsigned int dim) {
return ( dim == 0 ) ? 1 : BaseTraits::Dimension(dim - 1); }
GridTypeMapper_RepeatedTypes;
using tensor_reduced = iScalar<typename BaseTraits::tensor_reduced>;
using scalar_object = iScalar<typename BaseTraits::scalar_object>;
using Complexified = iScalar<typename BaseTraits::Complexified>;
using Realified = iScalar<typename BaseTraits::Realified>;
using DoublePrecision = iScalar<typename BaseTraits::DoublePrecision>;
static constexpr int Rank = BaseTraits::Rank + 1;
static constexpr std::size_t count = BaseTraits::count;
static constexpr int Dimension(int dim) {
return ( dim == 0 ) ? 1 : BaseTraits::Dimension(dim - 1); }
};
template<typename T, int N> struct GridTypeMapper<iVector<T, N>> {
using ObjectTraits = iVector<T, N>;
using BaseTraits = GridTypeMapper<T>;
static constexpr int Rank = 1 + BaseTraits::Rank;
static constexpr std::size_t count = N * BaseTraits::count;
static constexpr int Dimension(unsigned int dim) {
return ( dim == 0 ) ? N : BaseTraits::Dimension(dim - 1); }
GridTypeMapper_RepeatedTypes;
using tensor_reduced = iScalar<typename BaseTraits::tensor_reduced>;
using scalar_object = iVector<typename BaseTraits::scalar_object, N>;
using Complexified = iVector<typename BaseTraits::Complexified, N>;
using Realified = iVector<typename BaseTraits::Realified, N>;
using DoublePrecision = iVector<typename BaseTraits::DoublePrecision, N>;
static constexpr int Rank = BaseTraits::Rank + 1;
static constexpr std::size_t count = BaseTraits::count * N;
static constexpr int Dimension(int dim) {
return ( dim == 0 ) ? N : BaseTraits::Dimension(dim - 1); }
};
template<typename T, int N> struct GridTypeMapper<iMatrix<T, N>> {
using ObjectTraits = iMatrix<T, N>;
using BaseTraits = GridTypeMapper<T>;
static constexpr int Rank = 2 + BaseTraits::Rank;
static constexpr std::size_t count = N * N * BaseTraits::count;
static constexpr int Dimension(unsigned int dim) {
return ( dim == 0 || dim == 1 ) ? N : BaseTraits::Dimension(dim - 2); }
GridTypeMapper_RepeatedTypes;
using tensor_reduced = iScalar<typename BaseTraits::tensor_reduced>;
using scalar_object = iMatrix<typename BaseTraits::scalar_object, N>;
using Complexified = iMatrix<typename BaseTraits::Complexified, N>;
using Realified = iMatrix<typename BaseTraits::Realified, N>;
using DoublePrecision = iMatrix<typename BaseTraits::DoublePrecision, N>;
static constexpr int Rank = BaseTraits::Rank + 2;
static constexpr std::size_t count = BaseTraits::count * N * N;
static constexpr int Dimension(int dim) {
return ( dim == 0 || dim == 1 ) ? N : BaseTraits::Dimension(dim - 2); }
};
// Match the index