Namespace TempLat

Namespace List > TempLat

More...

Namespaces

Type	Name
namespace	Constants A class which implements the i*sigma matrices.
namespace	InitialConditionsType
namespace	KECCAK
namespace	Kernels
namespace	KernelsTypes
namespace	MPITags
namespace	Operators Extra namespace, as names such as Add and Subtract are too generic.
namespace	Symbols A namespace which contains symbols such as the epsilon tensor.
namespace	detail
namespace	device
namespace	device_kokkos
namespace	std_device

Classes

Type	Name
class	AbstractField <typename T, _NDim> A base class for a one-component field, providing common functionality and holding relevant pointers to memory tools.
class	AbstractMeasurer
class	AbstractModel <class R, NPOTTERMS, NS, NC, NU1FLDS, NSU2DOUBLET, NSU2FLDS, typename CSU1COUPLINGS, typename SU2DOUBLETU1COUPLINGS, typename SU2DOUBLETSU2COUPLINGS, typename SCALARU1AXIONCOUPLINGS, typename NONMINCOUPLINGS, typename T, NDIM, DEFECTSMODEL> A class which contains everything a model should have; models derive from here. Mother of all the models. The arguments are passed as template parameters.
class	AsComplexField <typename R> Adapts a getter whose eval() returns a complex<C> value into a complex-field expression (i.e. one exposing ComplexFieldGet(Tag<0>)/ComplexFieldGet(Tag<1>)). This is the inverse ofasFourier() .
class	AssignableCollectionBase <class Q, Args> A class which implements collections of object which are assignable.
class	AssignableCollectionBase< Q > <class Q>
class	AssignableTuple <Shift, Args> A class which makes tuple out of things that have an operator equal. Dispatch the equal.
class	Averager <typename T> A class which computes the average value of a getter.
class	AveragerHelper <typename vType, isComplexValued> A class which Average Routimes common to single field and list averager.
class	Averages A class used to compute common averages.
class	AxionCouplings A class which computes the matter currents and charge densities of the gauge fields.
class	BDPhaseHelper <typename T, NDim, gauge>
class	BackDiff <dir, typename R> A class which implements backward finite differences.
class	Benchmark A class to benchmark your code.
class	BinaryOperator <typename R, typename T> A parent class which implements the common methods that all binary operators (*, +, -,... ) share.
class	CStyleTime A class which returns date and time, pre C++17.
class	CenteredFields A class which computes centered versions of electric and magnetic fields.
struct	CheckAxionU1 <typename M, typename>
struct	CheckAxionU1< M, decltype((void) M::IsAxionU1Coupled, void())> <typename M>
struct	CheckerboardForEachWrapper <NDim, typename Functor> Wraps a foreach functor to apply checkerboard reconstruction.
struct	CheckerboardLayout <NDim> Wraps a LayoutStruct to iterate over only even or odd parity lattice sites.
struct	CheckerboardReduceWrapper <NDim, typename Functor> Wraps a reduce functor to apply checkerboard reconstruction.
class	ChiralProjector <typename R, typename T, typename Model>
class	CollectionBase <class Q, typename T, NDim, ISMOMENTUM, I>
class	CollectionBase< Q, T, NDim, ISMOMENTUM > <class Q, typename T, NDim, ISMOMENTUM>
struct	CollectionHelper <class Q, typename T, NDim, ISMOMENTUM, Start, End>
struct	CollectionHelper< Q, T, NDim, ISMOMENTUM, I, I > <class Q, typename T, NDim, ISMOMENTUM, I>
struct	CollectionSelector <class Q, typename T, NDim, ISMOMENTUM, N, SHIFT, ENABLE>
struct	CollectionSelector< Q, T, NDim, ISMOMENTUM, N, SHIFT, false > <class Q, typename T, NDim, ISMOMENTUM, N, SHIFT>
class	ComplexEvalComponent <typename R, N> The real (N==0) or imaginary (N==1) component of a getter whose eval() returns a complex value.
class	ComplexField <typename T, _NDim> A class which implements complex-valued fields.
class	ComplexFieldAddition <class R, class T> A class which implements complex field addition.
class	ComplexFieldAsFourier <typename R> A class which treats a complex field as an object in fourier space.
class	ComplexFieldAverager <typename T> A class which averages complex fields.
class	ComplexFieldBinaryOperator <typename R, typename T> A class which gtoups common features of binary field operators.
class	ComplexFieldConjugate <typename R> A class which computes the complex conjugate of a complex field.
class	ComplexFieldFourierView <typename T, NDim> A class which holds complex field in fourier space.
class	ComplexFieldGetter A class which get real and imaginary part.
class	ComplexFieldMultiplication <class R, class T> A class which multiplies two complex fields.
class	ComplexFieldOperator A class which implements common features of complex fields operators.
class	ComplexFieldSU2DoubletMultiplication <typename R, typename T> A class which implements the fundamental action of SU2.
class	ComplexFieldShifter <typename R, N> A class which implements spatial shifts for complex algebra.
class	ComplexFieldShifterByOne <typename R, _N>
class	ComplexFieldSubtraction <class R, class T> A class which implements complex subtraction.
class	ComplexFieldUnaryOperator <typename R> A class which groups common features of unary complex field operators.
class	ComplexFieldWrapper <class R, class T> A class which wraps two objects as a complex field.
struct	ComplexGetGetReturnType <typename T> A class which unpack the return type of a complex type.
class	ComplexScalarBase <NDIM, typename T, NC, typename CSU1COUPLINGS>
class	ComplexScalarKernels A class that computes the kernels for the complex scalars.
class	ComplexScalarMeasurer <typename T> A class which contains standard measurements for the complex scalars.
struct	Concat <class S1, class S2> A class which concatenates lists.
struct	Concat< CollectionBase< Q, T, NDim, ISMOMENTUM, I1s... >, CollectionBase< Q, T, NDim, ISMOMENTUM, I2s... > > <class Q, typename T, NDim, ISMOMENTUM, I1s, I2s>
struct	Concat< TagListBase< I1s... >, TagListBase< I2s... > > <I1s, I2s>
class	ConditionalFileStream A class which adds an owned file stream to the ConditionalStream .
class	ConditionalSayShort A class which only spits out to TTY if enabled == true.
class	ConditionalStream Because of MPI, we often only want to stream if we are root, etc. To simplify the notation, and simply always be able to write output << ..., we create a wrapper that accepts input with operator<<, and does the 'if'-ing inside that operator.
class	ConfigView <typename T, _NDim> A view on the field which, when interacted with, assures every time again that things are in configuration space, and possibly the ghost cells are updated when needed. The final Field class defaults to config space, which means it inherits from this class.
class	ConfirmGhosts A class which wraps the calls to confirm(Configuration/Fourier)Space, for classes that have it and objects that don't.
class	ConfirmSpace A class which wraps the calls to confirm(Configuration/Fourier)Space, for classes that have it and objects that don't.
class	ContainsSpace A class which checks if a string contains a space.
class	CouplingsManager <NMatter, NGauge, Bools>
class	CouplingsManager< NMatter, NGauge > <NMatter, NGauge> This class is a specialization of the CouplingsManager for the case where there are no gauge field couplings.
class	CouplingsManagerContainer <typename FloatType, NMatter, NGauge, Bools> A class which stores statically an array of booleans; useful to manage what couples to what.
struct	DefaultModelPars
class	DefectsMeasurer <typename T> A class which contains measurements of energies and scale factor.
class	DefectsObservables
class	Demangle A class which demangles from internal c++ to source code naming, taken from http://stackoverflow.com/a/4541470/2295722 .
class	Derivatives A class which aaplies vectorially the automatic derivative. Not used anywhere.
class	Diffusion
class	DimensionCountRecorder <NDim> A super class which records the number of dimensions on any call to confirmSpace.
class	DoEval A class which helps implementing the intermediate evaluation mechanism, extremely useful for matrix algebra.
class	Endianness A class which detects, at runtime, the endianness of the system.
class	Energies A class which computes the energy when working with our verlet-type algorithms. Assumes that the averages have already been computed.
class	EnergiesMeasurer <typename T> A class which contains measurements of energies and scale factor.
class	EnergySnapshotsMeasurer <typename Model> A class that prints snapshots of energy densities in configuration space.
class	Evolver <class Model>
class	Exception An exception which takes variadic arguments, all recorded into an error message.
class	ExpressionShifter <typename R, SHIFTS> A class which implements shifts in coordinates.
class	ExpressionShifterByOne <typename R, _N>
class	ExternalPowerSpectrumInitializer <typename T> A class that contains functions related with initial random fluctuations for scalar fields given by an external power spectrum.
class	ExtraFields <typename Model>
struct	FFTDecomposition <NDim> The MPI Cartesian decomposition an FFT backend will use for a given runtime setup.
class	FFTLayoutStruct <NDim> A struct which holds two memory layouts, which are inseparable:
class	FFTLibraryInterface <NDim> A pure abstract class (interface!) which defines the methods that you must implement for your new fft library to play well with us.
class	FFTLibrarySelector <NDim>
class	FFTMPIDomainSplit <NDim> A class which combines the MPIDomainSplit with theFFTLibrarySelector limits on domain splitting.
class	FFTNormalization <NDim> A class which applies the normalization to a block of memory after C2R and R2C fft's. You can choose between: fourier: C2R: 1/N, R2C: 1, mixed: C2R: 1/sqrt(N), R2C: 1/sqrt(N), config: C2R: 1, R2C: 1/N,.
class	FFTPlanInterface <typename T, NDim> Yes, for once a nested class. The interface for your to-be-implemented FFT plan, but forward and backward. Complex-to-real and real-to-complex.
class	FFTSessionGuard Yes, another nested class interface: for the session guard. Your constructor should take care of your_library_init(), your destructor should take care of your_library_cleanup(). These are the session-wide initialization / finalization calls.
struct	FFTTopology <NDim> The complete MPI topology an FFT backend will use: not just the grid shape, but the communicator whose rank order defines it and this rank's position within it.
class	FFTWGuard A class which guards intialization and finalization of FFTW. Only used by MPIGuard , which manually calls its destructor.
class	FFTWHermitianPartners <NDim> A class which holds all information about the redundancy in the complex values from a r2c fft. The redundancy comes from hermitian symmetry, so certain elements must be each other's complex conjugate. This class tells you which elements are each other's.
class	FFTWInterface <NDim> A class which implements all of FFTLibraryInterface . The larger methods are implemented in classes from which we inherit, in a linear chain:FFTWMemoryLayout andFFTWPlanner .
class	FFTWMemoryLayout <NDim> Implements part of FFTLibraryInterface , computes the local memory associated to the global problem, for FFTW.
class	FFTWPlanHolder <typename T, NDim> A class which holds FFT plans, and implements FFTLibraryInterface::PlanInterface<T>. The plans are implemented in std::shared_ptr's, so they are only desctructed when the last instance is destructed.
class	FFTWPlanner <NDim> A class which partially implements FFTLibraryInterface , namely the getPlans parts. That is, here the calls to the FFTW planner are made.
class	FFTWTranspositionFlags <NDim> A class which creates the transposition flags for FFTW, based on a layout.
class	Factorize A class which factorizes an integer into its primes.
class	Field <typename T, _NDim> A class which is a classical field on your n-dimensional equisized grid. You use it as a scalar field, a vector component, whatever. Template parameter is your type of floating point precision: float or double. Default: double.
class	FieldCollection <class Arg, N, flatAssign, SHIFTIND> A class which Field collections. Allows to have collection of composite vector fields as well.
class	FieldFunctionals A class which stores expressions of field functionals. By "field functional" we refer to any function of the field variables such as quadratic forms, e.g. <phi^2>, and others.
struct	FieldNDimCheck <NDimCheck>
class	FieldsAsInModel <typename Model> A class which holds extra fields, so that they can be used across the program.
class	FieldsNumbering A class which defines an ordering for the fields, to be used across the interface.
class	FileIO <NDim> A class which wraps HDF5 file saving and loading.
class	FileReader A class which reads input files.
class	FileToJSON A class which reads a file which contains valid JSON, and parses it into a json::JSON object.
class	FileToString A class which reads a file into a std::string. Constructor does not work, reading is actually done when the class is cast to a string.
class	FilesManager <NDim> Interface to switch between hdf5 and std output for measurements. This class hides the polymorphism under the hood.
class	FixedBackgroundExpansion <typename T> A class which implements fixed background expansion.
class	Flattener A class which flattents a composite collection.
class	FloatToString A class which holds one static method (format) which returns a nicer string representation of a floating point value, for display purposes (not too many significant digits).
class	FluctuationsGenerator <typename T> A class that contains functions related with initial random fluctuations for scalar fields.
struct	ForRangeHelper <i, j>
struct	ForRangeHelper< i, 0 > <i>
class	ForwDiff <dir, typename R> A class which implements forward finite differences.
class	ForwDij <dir, typename R> A class which implements forward finite sums.
class	FourierView <typename T, _NDim> A view on the field which, when interacted with, assures every time again that things are in fourier space, and possibly the ghost cells are updated when needed.
class	GWBase <NDIM, typename T>
class	GWProjector <typename R, typename T, typename Model> A class which computed the energy of the GWs, using the type 1 (neutral) TT projector.
class	GWProjectorType1 <typename R, typename T, typename Model>
class	GWProjectorType2 <typename R, typename T, typename Model>
class	GWProjectorType3 <typename R, typename T, typename Model>
class	GWsInitializer A class which is used to initialize the gravitational waves fields.
class	GWsKernels A class which stores the kernel for the GWs fields.
class	GWsMeasurer <typename T> A class which contains standard measurements for the GWs sector.
class	GaugeDerivatives A class which computes spatial scalar and (covariant) gauge derivatives.
class	GaussLaws A class that checks the preservation of the Gauss constraints, for both U1 and SU2 gauge sectors.
class	GetCPPTypeName A class which calls typeid and demangles it if possible.
class	GetComponent A class which calls getComp.
class	GetDeriv A class which gets derivates from all classes, also those that do not have derivative.
class	GetDx A getter for dx.
struct	GetFloatType <typename T> A template which extracts the float type from complexes.
struct	GetFloatType< F > <typename F>
struct	GetFloatType< complex< F > > <typename F>
struct	GetFloatType< device::array< T, N > > <typename T, N>
struct	GetGetReturnType <typename T> get(IterationCoordinates&) might be a function which returns a real value or a complex value. Sometimes we need to explicitly access what type it is.
class	GetKIR A getter for kIR.
class	GetNDim A class which returns the number of dimensions.
class	GetNGrid A class which returns the number of grid points in a specific dimensions.
struct	GetNScalars <typename CM>
struct	GetNScalars< CouplingsManager< NScalars, NU1, Coupled > > <NScalars, NU1, Coupled>
class	GetString A template-programming class which helps to get the 'toString'-value from any type, whether it has the toString-method or it is a scalar value.
class	GetToolBox A Helper class which returns the toolbox of an object, if it has one, and throws an exception if it doesn't. This is useful for measurement objects, which may or may not have a toolbox, but we want to be able to call getToolBox() on them without having to check if they have one first.
class	GetVectorComponentHelper <N, typename R> A class which returns one component of a vector as an object, keeping all fourier and co mechanics consistent. Mostly useful for wave numbers.
class	GetVectorSize A class which gets the size of a vector like composite object.
class	GhostBuster <NDim> A class which adds and removes (busts!) ghost cells to your layout. Pass the original layout and the target layout to the constructor. Then pass any pointer which satisfies for origin layout to the function call operator. And the rest will be history.
class	GhostStateKeeper A class which only holds the state of ghost cells: stale or up to date.
class	GhostSubarray <NDim> A class which holds an MPI_Datatype which is a subarray of the lattice, created by MPI_Type_create_subarray. The subarray is the ghost padding of the lattice, in one single dimension.
class	GhostSubarrayMap <NDim> A class which keeps track of all subarray types for a given layout, which in turn is described by the LayoutStruct . The map is for datatypes and dimensions. getSubArray<T>(dimension) is the only necessary public method.
class	GhostUpdater <NDim> A class which updates the ghost cells in our total memory block. By having the LayoutStruct , this class knows what is the ghostDepth.
class	GhostsHunter A class which helps implementing the automatic management of updating the ghost cells.
struct	HalfType A class which implement 1/2 as a type. Useful for squareroots.
struct	HasAsTupleCat <class, class> A class which detects whether or not an object has the hasTuplCat method.
struct	HasAsTupleCat< T, std::void_t< decltype(std::declval< T >().asTupleCat())> > <class T>
struct	HasExplicitCoordinateDependence <class T, class S> Enables adapting the coordinates inside a possible shifted view on this object. This is very expensive, time-wasting, which is why we want to be able to detect such an explicit coordinate dependence, and skip the coordinate-shift computation when it is not used, saving loads of cpu time.
struct	HasExplicitCoordinateDependence< T, std::void_t< decltype(T::EXPLICITCOORDINATEDEPENDENCE)> > <class T> Specialization: single object that mentions its explicit coordinate dependence.
struct	HasExplicitCoordinateDependence< T< S >, std::void_t<> > <T, typename S> Specialization: template object (Getter) whose enclosed class might mention its explicit coordinate dependence.
struct	HasExplicitCoordinateDependence< T< S1, S2 >, std::void_t<> > <T, typename S1, typename S2> Specialization: template object (Getter) whose enclosed class might mention its explicit coordinate dependence.
class	HeavisideStepFunction <typename R> Heaviside step function We use the convention that H(0) = 1 for simplicity.
struct	HermGetGetReturnType <typename T>
class	HermGetter A class which get real and imaginary part.
class	HermOperator
class	HermSymTracelessMultiplication <class R, class T> A class which multiplies two symmetric-traceless fields.
class	HermSymTracelessMultiplicationTrace <class R, class T> A class which multiplies two symmetric-traceless fields.
class	HermWrapper <typename R11, typename R12, typename R13, typename R22, typename R23, typename R33> A class which wraps six expressions, the upper triangle, as a hermitian 3x3 matrix.
class	HermitianPartners <NDim> An almost abstract class which your FFT library must implement, which maps the redundant entries in the complex representation of the FFT of your real values data, to their hermitian-conjugate partners.
class	HermitianValueAccounting A number of unique / independent real and imaginary floating point values in a memory layout.
class	HubbleConstraint A class that computes the hubble law in order to monitor "energy conservation".
struct	IntrinsicScales The result holder for getIntrinsicRescaleToGetUnnormalizedFFT: two labeled double values.
struct	IsCompositeHelper <class, N> A class which allows to check whether a class is composite or not. Allows to write general function that works on composite classes.
struct	IsCompositeHelper< T, 1 > <class T>
class	IsInContainer A class which checks wheter container contains some objects. Need to be std compatible. https://stackoverflow.com/a/19299611 .
struct	IsSU2DaggerT <class T>
struct	IsSU2DaggerT< SU2Dagger< R > > <class R>
struct	IsTupleLike <class, class> A class which tests whether or not a class behaves like a tuple.
struct	IsTupleLike< T, std::void_t< typename std::tuple_size< T >::type > > <class T>
class	IsVariadicIndexTester
class	KBins <typename T>
class	KeccakHash A class which computes (statically) the keccak hash of one string.
class	KeccakHashBareClass A class which computes the keccak hash of one string, which is passed to the method compute. Can compute only once, then keeps the state. Throws an exception if compute is called twice.
class	KokkosFFTMemoryLayout <NDim> Implements part of FFTLibraryInterface , computes the local memory associated to the global problem, for KokkosFFT. Build on this to replace KokkosFFT.
class	KokkosFFTPlanHolder <typename T, NDim> A class which implements part of FFTLibraryInterface::PlanInterface, holding the KokkosFFT plans in shared_ptr's.
class	KokkosFFTPlanner <NDim> A class which implements part of FFTLibraryInterface , the planner part. Here all calls to KokkosFFT_plan ... are made.
class	KokkosFFTTranspositionFlags <NDim> A class which determines the transpose-flags for the KokkosFFT planners, corresponding to a given layout.
class	LatinIndicesList <Args> A class which an enumerated list which starts from 1 rather than 0.
class	LatticeForwardGradient <typename R> A class which implements the forward gradient.
class	LatticeLaplacian <typename R> A class which implements the laplacian.
struct	LatticeParameters <typename T>
struct	LayoutStruct <NDim> Holds the result of FFTLibraryInterface::computeLocalSizes . In itself, has practically no logic, only forwards all the getters and setters to their respective owners. SeeLayoutStructGlobal ,LayoutStructLocal andLayoutStructLocalTransposed .
class	LayoutStructGlobal <_NDim> A class which holds some memory informations.
class	LayoutStructLocal <_NDim> A class which localSizes: the local size in each dimension. localStart: the coordinate of the first entry in local memory, in the global coordinate space.
class	LayoutStructLocalTransposed <_NDim> transitionMap: a map of the dimensions, for transposition in memory. E.g. {0, 1, 2, 3} is untransposed 4d, {1, 0, 2, 3} is FFTW transposed. In other words, the entries in transitionMap are in line with the entries in localStarts/-Sizes, and their value indicates the physical-space dimension of that entry.
class	LeapFrog <class T> A class which implements a leapfrog scheme to evolve scalar singlets, complex scalars, SU2 doublets, and U(1) and SU(2) gauge fields.
class	ListAbsoluteValue <typename R> A class which adds two getters. Holds the expression, only evaluates for a single element when you call Multiply::get(pIterCoords).
class	ListAddition <typename R, typename T> A class which adds two getters. Holds the expression, only evaluates for a single element when you call Multiply::get(pIterCoords).
class	ListBinaryOperator <typename R, typename T> Wrapper for algebra with FieldCollection . Here we define the base methods for checking and everything. Can use this algebra to implement matrix and vector algebra! IDEA: statically type MATRIXTYPE type and template methods of the type AddMatrixTypes<R,T>::type.
class	ListComplexConjugate <typename R> A class which implements the complex conjugation for the list algebra.
class	ListDivision <typename R, typename T>
class	ListExponential <typename R> A class which implements the exponentiation for the list algebra.
class	ListLaplacian <typename R> A class which applies a minus sign. Holds the expression, only evaluates for a single element when you call Multiply::get(pIterCoords).
class	ListLog <typename R> A class which implements the logarithm for the list algebra.
class	ListMultiplication <typename R, typename T>
class	ListPower <typename R, typename T>
class	ListPowerN <N, typename R>
class	ListShifter <class R, N> A class which implements shifts for the list algebra.
class	ListShifterByOne <typename R, N>
class	ListSubtraction <typename R, typename T> A class which adds two getters. Holds the expression, only evaluates for a single element when you call Multiply::get(pIterCoords).
class	ListUnaryMinus <typename R> A class which adds two getters. Holds the expression, only evaluates for a single element when you call Multiply::get(pIterCoords).
class	ListUnaryOperator <typename R> A class which.
class	LoadBalance A class which given and a number of threads nth, return nth integer which reprensents the most even splitting of the number.
class	LogMutex A class which holds a mutex, specific for output (log).
class	MPIAllReduce A class which calls MPI_Allreduce, meaning that all processes submit their value and receive the combined value of all processes, given an operation to combine the values.
class	MPICartesianExchange A class which handles the exchange between neighbours in the cartesian group. Has two methods: exchangeUp and exchangeDown, which take as input a datatype, a dimension (because you need to specify what is up and down), a pointer for the sending memory and a pointer for the receiving memory.
class	MPICartesianGroup A class keeps the books regarding the process layout relative to the physics lattice.
class	MPICartesianNeighbours A class which fetches and stores the neighbours in all dimensions. Internally just contructs a std::vector<MPICartesianNeighboursSingleDimension> with each entry corresponding to its associated dimension.
class	MPICartesianNeighboursSingleDimension A class which fetches and stores the two neighbours in a single dimension.
class	MPICommReference A class which holds an MPIComm. The Comm WILL DESTRUCT when the last owner of a reference to this class destructs its instance. Unless it is MPI_COMM_WORLD, of course.
class	MPIDebuggerHanger A class which can be used to hang a serial debugger like gdb to individual threads.
class	MPIDomainSplit A class which factorizes an integer into N roughly equal-size integers. That is, our best guess for the domain decomposition.
class	MPIGuard A class which guards intialization and finalization of pure MPI. Only used by SessionGuard , which manually calls its destructor, but which also holds the FFTW and other guards.
class	MPISendReceive A class which holds all methods that do plain Send and Receive in MPI. Just call the send and receive methods with any scalar or vector-like input, associated rank numbers and tags. Unused for now.
class	MPITagsJustCompile A class which just compiles. Unit test: ctest -R test-mpitags.
class	MPITypeConstants
class	MatrixBinaryOperator <typename R, typename T> A class which gtoups common features of binary field operators.
struct	MatrixGetGetReturnType <typename T>
class	MatrixGetter A class which get real and imaginary part.
class	MatrixMatrixMultiplication <class R, class T> A class which multiplies two general (full, 9-component) 3x3 matrix fields. Distinct from the symmetric-traceless products (sym/herm/scalar SymTracelessMultiplication), which store fewer independent components and use the traceless relation.
class	MatrixMatrixMultiplicationTrace <class R, class T> A class which computes the trace of the product of two matrix fields. Used for the projector of GWs.
class	MatrixOperator A class which implements common features of matrix fields operators.
class	MatrixWrapper <typename R11, typename R12, typename R13, typename R21, typename R22, typename R23, typename R31, typename R32, typename R33> A class which wraps nine expressions as a general 3x3 matrix, given row by row.
class	MatterCurrents A class which computes the matter currents and charge densities of the gauge fields.
class	Maximum <typename T>
class	MeansMeasurer A class which implements common measurement to all fields, like mean and variance, in a standardized format.
class	MeasurementsSaver <typename T> A class which implements an interface to the measurement IO. Allow to switch between different format.
class	MeasurementsSaverStd <typename T> A class which is used to save measurements using the standard library.
class	Measurer <typename Model, typename T> A class which contains the measurements.
class	MemoryBlock <typename T, NDim> A class which holds a block of memory. Feel free to pass it around and copy: the pointer is itself kept inside a shared pointer. Only when the last owner is destructed, the memory is freed.
class	MemoryLayoutState A class which tracks the three layout states the memory can have. If state is undefined, all the is___Space() variants return true. So you don't wast time FFT'ing trash etc.
class	MemoryManager <typename T, NDim> A class which holds a single lattice in memory, and tracks and moves between various ghost states. Templated for the memory type, typically float or double. All the confirm___Space() functions return a device::Idx, which counts the amount of work done. Ignore that, but it is important for testing purposes. NOTE that the memory access operators (T* and operator[]) do NOT verify if memory was allocated.
class	MemoryToolBox <_NDim> A class which collects all the tool classes which deal with memory(-state) manipulation. Make one toolbox using the makeShared method, and instantiate as many memory managers as you want, with identical layouts!
class	ModelInitializer <typename T> A class initializes a model's fields and the scale factor.
class	ModelParametersBase <typename T>
class	MomentumInterpolator <typename T, NDim>
class	MomentumMultiplicity <typename T, NDim> Computes, for each Fourier-space site, the multiplicity of modes sharing the same rounded momentum magnitude bin. Returns 1/multiplicity on eval. Generalized to arbitrary NDim.
class	MultipleParameterGetter <typename T> A class which returns multiple parameters.
class	NamedTmpFile A class which creates a named temporary file, accepts input, and can close and delete.
class	NeutDiff <dir, typename R> A class which implements neutral finite differences.
class	NeutDij <dir, typename R> A class which implements neutral finite sums.
class	NonMinimalCoupling
class	NonMinimalCouplingBase <typename T, NS, typename NONMINCOUPLINGS>
class	NormGradientSquare <typename R> A class which computes the gradient square norm.
struct	Number <typename T> A runtime-mutable scalar value that participates in the expression template algebra.
struct	NumberCollection <typename T, N> A lightweight fixed-size collection of Number<T> values.
class	NumericalIntegrator A class which encapsulate some newto-cotes integration formula. Assume that the point are equispaced.
class	OccupationNumberMeasurer A class which computes the occupation number.
struct	OneType A class which represents one. Attempt to simplify derivative expressions.
class	OutputStream <typename R> A class which handles output, with convenient savetxt function.
class	PITensor A class which computes the componentes of the Anisotropic Tensor source of Gravitational Waves.
class	PairMaker Small class which splits strings into two and make a pair out of it.
class	ParafaftMemoryLayout <NDim> Memory layout computation for parafaft.
class	ParafaftPlanHolder <typename T, NDim> Plan holder for parafaft FFT transforms.
class	ParafaftPlanner <NDim> Plan creation for parafaft FFT transforms.
class	ParameterGetter <typename T> Class for parameter .handler. Special getter which can directly cast to T.
class	ParameterParser
class	ParenthesisStripper A class which strips a string of its parenthesis if they are first and last characters.
class	PauliVectorsAlgebra A class which implements the SU2 algebra at the single element level.
class	PoorMansProfile A class for the poor man's profiling: prints out the map upon destruction.
class	PositionVerlet <typename T> A class which implements a position Verlet algorithm that evolves scalar singlets, complex scalars, SU2 doublets, and U(1) and SU(2) gauge fields.
struct	PositionVerletParameters <typename T> A class which stores the composition parameters for position Verlet schemes.
class	PostGet A class which wraps the calls to confirm(Configuration/Fourier)Space, for classes that have it and objects that don't.
class	Potential A class which manipulates the potential and the its derivatives.
class	PowerSpectrumMeasurer <typename T, NDim> A class which computes the power spectrum, with the appropriate rescaling to make it volume independent.
class	PreGet A class which wraps the calls to confirm(Configuration/Fourier)Space, for classes that have it and objects that don't.
class	PrettyToString A class which attempts to write a float removing the unnnecessary 0 at the end. Not completely robust as this is a complicated problem but good enough for our purposes.
class	RK2NStorage <typename Model> A class which implements low storage ("2N-storage") explicit RK methods.
class	RK2NStorageFields <typename Model> A class which implements low storage ("2N-storage") explicit RK methods.
class	RK2NStorageParameters <typename T> A class which stores coefficients for 2N-storage RK.
class	RadialBinComputer A class which returns an integer bin for a given fp value.
class	RadialProjectionRebinner <typename T> A class which takes a std::vector<RadialProjectionSingleBinAndValue<T>> and rebins it into a smaller number of bins.
class	RadialProjectionResult <typename T> A class which holds the result of a radial projection, with per bin the average position of each entry (the horizontal axis in your plot..), the variance in the position, the average value, the sample variance (= <f^2> - <f>^2 ) of the values, and the number of entries in a bin (multiplicity).
struct	RadialProjectionSingleBinAndValue <typename T> A class which combines a pair of RadialProjectionSingleDatums, one for the bin position, one for the function value for that bin.
struct	RadialProjectionSingleDatum <typename T> A class which holds a single bin which results from the radial projection of something. Used for describing both the bin position and values, namely combined in RadialProjectionSingleBinAndValue .
class	RadialProjectionSingleQuantity <typename T> A class which holds properties of a quantity (average, variance, min, max), each in a separate vector. Useful during the integration, will be transposed after the integration is done.
class	RadialProjector <typename T> A class which projects any N-D lattice on its positive-definite radial coordinate. In other words, integrating out all the angular dimensions. When in Fourier-space, this routine takes into account what the redundancies are. Only the unique values are counted. Real-valued entries get weight 0.5 (they only contribute one float value out of the two for each complex value), and of the hermitian pairs, only the positivePartner is taken into account.
class	RandomGaussian <typename T> A gaussian random variable. Is aware of its own state and counts the number of values that have been returned.
class	RandomGaussianFieldHelper <typename T, NDim, Space, Real, Unitary> A class which initializes a complex random gaussian field. ONLY WORKS FOR FFTW R2C complex layouts. It has a state, which counts the number of times it has been used. As in the backend a deterministic, stateless RNG is used, we need to keep track of this in order to generate a new set of random numbers each time.
class	RandomUniform <typename T, typename RNG> A class which gives pseudo random counter-based rng, based on a string random seed, stable across platforms.
class	ResolutionPreserving A class that implements the resoluton-preserving techniques (including fattening and extra-fattening).
class	RunParameters <typename T> A class which contains the parameters useful to run a simulation but not model specific (dt for example).
class	SU2Addition <typename R, typename T> A class which implements the sum of su2 matrices.
class	SU2Averager <typename T> An averager for su2. Allows to take into account cached operations consistently.
class	SU2Base <NDIM, typename T, NSU2FLDS>
class	SU2BinaryOperator <typename R, typename T> A class which implements basic features of su2 binary operators.
class	SU2Commutator <typename R, typename T> A class which computes the commutator of two SU(2) matrices.
class	SU2Dagger <typename R> A class which implements the hermitian conjugation.
class	SU2Dotter <typename R, typename T> Lie-algebra inner product <A,B> = sum_{a=1,2,3} A_a B_a of two SU(2)-valued expressions, returned as a scalar.
class	SU2Doublet <typename T, _NDim> A class which implements su2doublets.
class	SU2DoubletAddition <typename R, typename T> A class which implements the sum of 2 su2 doublets.
class	SU2DoubletAverager <typename T> An averager specialised for SU2Doublet . Allows to take into account cached operations consistently.
class	SU2DoubletBinaryOperator <typename R, typename T> A class which implements common features to SU2Doublet binary operators.
class	SU2DoubletDagger <typename R> A class which compute the hermitean conjugate of Doublets.
class	SU2DoubletDotter <typename R, typename T> A class which computes the scalar product of two doublets.
struct	SU2DoubletGetGetReturnType <typename T> A class which gives the return type of the get function of one of the doublet element.
class	SU2DoubletGetter A class which return the SU2DouletGet method.
class	SU2DoubletKernels A class which holds the kernels for the SU2Doublet .
class	SU2DoubletMeasurer <typename T> A class which contains standard measurements for the SU2 doublets.
class	SU2DoubletOperator <NDim> A class which groups some features of the SU2Doublet ops.
class	SU2DoubletSectorBase <NDIM, typename T, NSU2DOUBLET, typename SU2DOUBLETU1COUPLINGS, typename SU2DOUBLETSU2COUPLINGS>
class	SU2DoubletShifter <typename R, N> A class which shifts a doublet in space.
class	SU2DoubletShifterByOne <typename R, _N>
class	SU2DoubletSubtract <typename R, typename T> A class which implement the Subtraction between two su2 doublets.
class	SU2DoubletUnaryOperator <typename R> A class which groups common features to su2doublets unary operators.
class	SU2DoubletWrapper <class A, class B, class C, class D> A class which creates a doublet out of some preexisting objects.
class	SU2ExpMap <typename R> A class which computes the exponential map for su(2).
class	SU2ExpMapInv <typename R> A class which computes the inverse exponential map for SU2 (log).
class	SU2Field <typename T, _NDim> A class which implements a SU2 field (group). We choose a representation with 4 real numbers per lattice site, c0, c1, c2, c3. These are subject to the unitarity constraint c0^2 + c1^2 + c2^2 + c3^2 = 1, which can be enforced by the unitarize() method. A single link variable is then represented as U = c0 * I + i * (c1 * sigma1 + c2 * sigma2 + c3 * sigma3), where sigma1, sigma2, sigma3 are the Pauli matrices.
struct	SU2GetGetReturnType <typename T> A class which determines what is the return type of the composite su2 objects.
class	SU2Getter A class which return the SU2Get method.
class	SU2GroupWrapper <class A, class B, class C> A class which computes an element of the group SU(2). By that, we mean that det=1 is imposed as a constrained on the 0th element, like in the SU2Fields.
class	SU2Initializer A class that initializes the SU(2) gauge sector (both non-Abelian gauge fields and SU2 doublets)
class	SU2Kernels A class that computes the kernel for the SU2 gauge fields.
class	SU2LieAlgebraField <typename T, _NDim> A class which implements a SU2 field (algebra). Same than the group, except set 0 component to 0 and has a function which returns its components wrt to sigma/2 instead of sigma, which is more conventional for the algebra (but internally, also expanded as a function of sigma).
class	SU2Measurer <typename T> A class which contains standard measurements for the SU2 gauge fields.
class	SU2Multiplication <typename R, typename T> A class which implement SU(2) matrix multiplication.
class	SU2Operator A class which contains basic info about su2 algebra.
class	SU2SU2DoubletMultiplication <class R, class T> A class which implemetns SU2 SU2Doublet multiplication.
class	SU2Shifter <typename R, N> A class which applies the shift method to su2 objects.
class	SU2ShifterByOne <typename R, _N>
class	SU2Subtraction <typename R, typename T> A class which implements the SU2 Subtraction.
class	SU2UnaryOperator <typename R> A class which implements basic features of su2 unary operators.
class	SU2Wrapper <class A, class B, class C, class D> A class which construct a SU2-like object.
class	ScalarBase <NDIM, typename T, NS>
class	ScalarComplexFieldMultiply <typename R, typename T> A class which implements scalar multiplication over complex numbers.
class	ScalarSU2Multiplication <typename R, typename T> A class which multiplies SU2 field by complex fields.
class	ScalarSingletInitializer A class which is used to initialize the scalar singlets.
class	ScalarSingletKernels A class that computes the kernel for the scalar singlets.
class	ScalarSingletMeasurer <typename T> A class which contains standard measurements for scalar singlets.
class	ScalarSymTracelessMultiply <typename R, typename T> A class which implements scalar multiplication over symmetric traceless numbers.
class	ScalarU1AxionBase <typename T, typename SCALARU1AXIONCOUPLINGS>
class	ScaleFactorBase <typename T>
class	ScaleFactorInitializer A class which is used to initialize the scale factor.
class	ScaleFactorKernels A class that computes the kernel for the scale factor equation.
class	ScaleFactorMeasurer <typename T> A class which measure the scale factor, its derivative and the Hubble rate.
class	SessionGuard A class which holds all the guards: fftw, other fft libraries and mpi. Only one instance per process is allowed. Throws an exception if that condition is violated.
class	SimulationManager <NDim> A class which handles start and stop of a simulation. Also used to create the info file.
class	SpaceStateInterface <NDim> An interface class which all getter-like objects inherit from, so we can access their confirm(Config/Fourier)Space methods by their virtualness.
class	SpatialCoordinate <NDim> A class which implements spatial coordinates.
class	SpectrumSaver <typename T> A class which saves spectra to files.
class	SpectrumSaverStd <typename T> A class which implements the std spectra output.
class	Spline <typename T>
struct	SplineData <typename T>
class	Stacktrace A class which holds the stacktrace to the point where it was instantiated.
class	StaticWarning
class	StreamCacher A container that sits at the receiving end of a stream, and spits out everything to the mutexed std::cerr only when it is destructed -> that the end of the line;.
class	StringConverter <class T> A class which wraps a single function, splitting it in lines and passing each line to ParameterGetter , returning the result in your provided MultipleParameterGetter<T>.
class	StringTrimmer A class which trims strings on all ends. In place: [lr]trim(std::string). Copy: std::string [lr]trimmed(std::string)
struct	SymGetGetReturnType <typename T>
class	SymGetter A class which get real and imaginary part.
class	SymOperator
class	SymSymTracelessMultiplication <class R, class T> A class which multiplies two symmetric-traceless fields.
class	SymSymTracelessMultiplicationTrace <class R, class T> A class which multiplies two symmetric-traceless fields.
class	SymTracelessAddition <typename R, typename T> A class which implements symmetric-traceless field addition.
class	SymTracelessBinaryOperator <typename R, typename T> A class which gtoups common features of binary field operators.
class	SymTracelessConjugate <typename R> A class which implements conjugation of all the elements of a symmetric-traceless matrix.
class	SymTracelessField <typename T, _NDim> A class which implements symmetric-traceless matrix field used for GWs.
class	SymTracelessFieldAsFourier <typename R> A class which treats a symmetric-traceless field as an object in fourier space.
class	SymTracelessFieldFourierView <typename T, NDim> A class which holds symmetric-traceless field in fourier space.
class	SymTracelessFieldShifter <typename R, N> A class which implements spatial shifts for symmetric traceless algebra.
class	SymTracelessFieldShifterByOne <typename R, _N>
struct	SymTracelessGetGetReturnType <typename T> A class which unpack the return type of a complex type.
class	SymTracelessGetter A class which get real and imaginary part.
class	SymTracelessOperator
class	SymTracelessSubtraction <class R, class T> A class which implements complex subtraction.
class	SymTracelessUnaryOperator <typename R> A class which groups common features of unary complex field operators.
class	SymTracelessWrapper <class R0, class R1, class R2, class R3, class R4, class R5> A class which wraps six expressions as a symmetric 3x3 matrix whose trace is subtracted on evaluation.
class	SymWrapper <typename R11, typename R12, typename R13, typename R22, typename R23, typename R33> A class which wraps six expressions, the upper triangle, as a symmetric 3x3 matrix.
class	TDDAssertion The function to call for the evaluation of each test.
class	TDDContainer <class TESTME> The container to instantiate if you want to register your class for testing.
class	TDDContainerBase A class which provides the interface for TDDContainers.
class	TDDContainerDummy
class	TDDRegister A class which registers all unit tests in the currently linked binaries, and runs all the unit tests when called accordingly.
class	Tag <N> A class which implements homemade compile time constants.
class	TagListBase <I> A class which implements an enumerated list.
struct	TagListHelper <Start, End>
struct	TagListHelper< I, I > <I>
class	TempLatArray <typename T, N, shift> A class which makes array compatible which getComp algebra.
class	TempLatVector <typename T, shift> A class which makes vector compatible with GetComponent algebra and defines a operator(int i).
class	ThreadSettings A class which does bookkeeping, number of threads allowed by hardware, number of threads allowed by user, etc.
class	TimeSpent A class which measures the wall time since its construction.
class	Timer A simple timer class to measure elapsed time.
class	ToolWithOwnMemory <typename T, NDim> A base class for powerspectrum and twopointcorrelator: holds an optionally persistent block of memory of the same shape as the Getter that you pass to it.
class	TopologicalChargesMeasurer <typename T> A class to measure gauge fields topological charges.
class	TranspositionMap <NDim> A class which maps between two orderings.
class	TripleStateLayouts <NDim> A class which keeps three layouts of the memory for one MPI task in a global exact hypercube.
struct	TupleMakerHelper <typename R, bool>
struct	TupleMakerHelper< R, true > <typename R>
class	U1Base <NDIM, typename T, NU1FLDS, NS, NC, typename SCALARU1AXIONCOUPLINGS>
class	U1Exponential <typename R> Exponential map for U(1).
class	U1Initializer A class that initializes the U(1) gauge sector (both Abelian gauge fields and complex scalars)
class	U1Kernels A class that computes the kernel of the U(1) gauge fields.
class	U1Measurer <typename T> A class which contains standard measurements for the U1 gauge fields.
class	UnaryOperator <typename R> A parent class which implements the common methods that all unary operators (-, sqrt ) share.
class	UnbinnedPowerSpectrumMeasurer <typename T, NDim> A class which computes the power spectrum, with the appropriate rescaling to make it volume independent.
class	UnbinnedRadialProjectionResult <typename T> A class which holds the result of a radial projection without binning. For each possible value of the Fourier coordinate it saves: the average value, the sample variance (= <f^2> - <f>^2 ) of the values, and the number of entries in a bin (multiplicity).
class	VectorDotter <typename R, typename T> A class which takes two VectorGetters, and implements a special get method which returns the dot-product / contraction of the two vectors.
class	VectorFieldCollection <class Arg, N, SHIFTIND, flatAssign> A class which allows to make collections of vector fields.
class	VelocityVerlet <typename T> A class which implements a velocity verlet algorithm that evolves scalar singlets, complex scalars, SU2 doublets, and U(1) and SU(2) gauge fields.
struct	VelocityVerletParameters <typename T> _A class which stores the composition parameters. See appendix in "The art of simulating the early
Universe", arXiv:2006.15122._
struct	VerbosityLevels A struct with a bunch of flags with enable various output messages. Use to your advantage.
class	WallAverager <typename T> A class which computes the average value of a getter over the first n-1 coordinates, returns a vector.
class	WaveNumber <NDim> A class which allows for accessing (unscaled, dimensionless, index-valued) various expressions involving the fourier coordinates.
class	Weights A class that defines the weights used to measure the energy contained in the strings. Vy defect, we use weights based on the potential, normalized such that they are equal to unity at the core of the defects.
struct	ZeroType A class which represents zero. Attempt to simplify derivative expressions.
struct	holdStaticGuard I wrapped this in a struct for a very specific case: If we have multiple translation units (cpp files) which include this header, and each calls getFFTSessionGuards, then we will have multiple static variables, one per translation unit, and the guards will not work as intended. By wrapping it in a struct, we ensure that there is only one instance of the static variable, no matter how many translation units include this header.
struct	is_std_vector <typename T>
struct	is_std_vector< std::vector< T, A > > <typename T, typename A>
struct	number_to_skip_as_tuple <typename R, class> A class which make a tuple from a composite object.
struct	number_to_skip_as_tuple< R, std::void_t< decltype(R::numberToSkipAsTuple)> > <typename R>
struct	static_max <N, M> A class which compute the maximum at compile time.
struct	std_atomic_type <typename T, typename> A SFINAE struct to get the base type of a composite container.
struct	std_atomic_type< T, std::void_t< typename T::value_type > > <typename T>
struct	tuple_size <typename Tuple, class>
struct	tuple_size< Tuple, std::void_t< decltype(Tuple::size)> > <typename Tuple>
struct	tuple_size_helper <typename Tuple, class> A class which overloads tuple_size for the fcn composite objects.
struct	tuple_size_helper< Tuple, std::void_t< decltype(std::tuple_size< Tuple >::value)> > <typename Tuple>
struct	warn_if <condition> A compile-time warning based on template programming values. Taken from https://www.reddit.com/r/cpp/comments/66o1ju/does_a_static_warn_exist/ .
struct	warn_if< false > <>

Public Types

Type	Name
typedef std::conditional_t< std::is_integral_v< T >||std::is_floating_point_v< T >, double, T >	AveragerReturnType
typedef BDPhaseHelper< T, NDim, true >	BDPhasePi2A
typedef BDPhaseHelper< T, NDim, false >	BDPhasePi2E
enum	CANONICALTYPE
typedef typename CollectionSelector< Q, T, NDim, ISMOMENTUM, N, SHIFT, N==0 >::type	Collection
typedef typename Concat< S1, S2 >::type	Concat_t
enum	EvolverType An enum, listing all available evolver types:
enum	FFTBackendTag A class which sets up the interface with the appropriate FFT library. Once you have implemented the FFTLibraryInterface for your library, add it to the logic here.
typedef WaveNumber< NDim >	FourierSite
enum	HermitianPartnersMode
enum	HermitianRedundancy Tracks which entries in the layout carry redundant information, and if so, what information. This, again, assumes FFTW layout.
typedef IsCompositeHelper< R, tuple_size< decltype(std::remove_reference< R >::type::Getter::get(std::declval< R & >(), std::declval< Tag< 0 > >()))>::value >	IsComposite
typedef typename TagListHelper< Start, End >::type	MakeSeqImplTagList_t
typedef typename CollectionHelper< Q, T, NDim, ISMOMENTUM, Start, End >::type	MakeSeqImpl_t
typedef typename TagListHelper< 0, N - 1 >::type	MakeSeqTagList_t
typedef typename CollectionHelper< Q, T, NDim, ISMOMENTUM, 0, N - 1 >::type	MakeSeq_t
typedef parafaft::FFTWBackend< T >	ParaFaFT_Backend
enum	ParameterImportance
enum device::Idx	Parity
typedef RandomGaussianFieldHelper< T, NDim, SpaceStateType::Fourier, false, false >	RandomGaussianField
typedef RandomGaussianFieldHelper< T, NDim, SpaceStateType::Configuration, false, false >	RandomGaussianFieldConfig A Gaussian random field directly in configuration space: independent real N(0,1) white noise per lattice site (flat spectrum). NOT equivalent to drawing in Fourier space and transforming unless.
typedef RandomGaussianFieldHelper< T, NDim, SpaceStateType::Fourier, true, false >	RandomRayleighField
typedef RandomGaussianFieldHelper< T, NDim, SpaceStateType::Fourier, false, true >	RandomUniformUnitaryField
enum	SpaceStateType An enum for passing the right space type, all while having the compiler type check it.
typedef typename TagListHelper< START, END >::type	TagList
typedef TupleMakerHelper< R, IsComposite< R >::value >	TupleMaker
typedef ComplexField< T, NDim >	U1Field A U(1) group-valued field.
typedef FieldCollection< Arg, GetNDim::get< Arg >(), flatAssign, 1 >	VectorField A class which Field collections. Allows to have vector fields, index starting from one.

Public Functions

Type	Name
DEVICE_FUNCTION bool	AlmostEqual (const T1 & a, const T2 & b, const T3 & epsilon=std::sqrt(std::numeric_limits< T3 >::epsilon())) we are comparing computed floats, so allow for some epsilon
DEVICE_FUNCTION bool	AlmostEqual (const complex< T > & a, const complex< T > & b, const T epsilon=std::sqrt(std::numeric_limits< T >::epsilon())) overload for complex values. __
DEVICE_FUNCTION bool	AlmostEqual (const std::array< T, N > & a, const std::array< T, N > & b, const T epsilon=std::sqrt(std::numeric_limits< T >::epsilon())) overload for arrays
auto	B4NA (const R & Us, Tag< 1 >)
auto	B4NA (const R & Us, Tag< 2 >)
auto	B4NA (const R & Us, Tag< 3 >)
auto	BackwardCovariantDerivative (Args... args) A class which.
void	CDemangle (std::ostream & stream, char * start)
auto	CField (Field< T, NDim > f1, Field< T, NDim > f2)
auto	CenteredCovariantDerivative (Args... args) A class which computes centered covariant derivatives.
auto	CenteredCovariantDerivativeO4 (Args... args) A class which computes a O(dx^4) discrete covariant derivative.
auto	CenteredDerivative (T t)
auto	CenteredDerivativeO4 (T t)
ComplexFieldWrapper< R, T >	Complexify (const R & r, const T & t)
HermWrapper< R11, R12, R13, R22, R23, R33 >	ConstructHerm (const R11 & r11, const R12 & r12, const R13 & r13, const R22 & r22, const R23 & r23, const R33 & r33)
MatrixWrapper< R11, R12, R13, R21, R22, R23, R31, R32, R33 >	ConstructMatrix3x3 (const R11 & r11, const R12 & r12, const R13 & r13, const R21 & r21, const R22 & r22, const R23 & r23, const R31 & r31, const R32 & r32, const R33 & r33)
SymWrapper< R11, R12, R13, R22, R23, R33 >	ConstructSym (const R11 & r11, const R12 & r12, const R13 & r13, const R22 & r22, const R23 & r23, const R33 & r33)
SymTracelessWrapper< R0, R1, R2, R3, R4, R5 >	ConstructSymTraceless (const R0 & r0, const R1 & r1, const R2 & r2, const R3 & r3, const R4 & r4, const R5 & r5)
Operators::DiracDeltaFunction< T >	DiracDelta (const T & a) Exposing our newly define multiplication operation to the world.
auto	DoesNotThrow (Lambda ll) A helper for negating Throws.
void	ExceptionArgumentUnpacker (std::stringstream & stream) Recursion stopper for helper function for unpacking the variadic arguments of the Exception constructor.
void	ExceptionArgumentUnpacker (std::stringstream & stream, T t, Args... args) Helper function for unpacking the variadic arguments of the Exception constructor.
auto	Grad2 (R pR)
constexpr auto	Grad2 (R)
auto	Imag (T && t) A class which returns imaginary part of a fields or complex number.
auto	Imag (T && t)
auto	Imag (T && t) Imaginary part of a getter whose eval() returns a complex value. Bridges it into the complex-field protocol first, so Imag(f) == Imag(asComplexField(f)).
consteval bool	IsEqual (auto i, auto j)
consteval bool	IsLess (auto i, auto j)
consteval bool	IsLessOrEqual (auto i, auto j)
consteval bool	IsMore (auto i, auto j)
consteval bool	IsMoreOrEqual (auto i, auto j)
auto	LatForwardGrad (R pR)
auto	LatLapl (const R & r)
auto	LatLapl (R pR)
constexpr auto	LatLapl (R)
constexpr MPI_Datatype	MPITypeSelect () A bunch of compile-time templates for getting the right MPI constants for your type.
	MakeException (FFTWHermitianPartnersWrongSizeException)
	MakeException (FFTWMPISendrecvCountOverflowException)
	MakeException (FFTWCompiledWithoutSinglePrecisionSupport)
	MakeException (KokkosFFTMemoryLayoutException)
	MakeException (KokkosFFTPlannerException)
	MakeException (ParafaftMemoryLayoutException)
	MakeException (ParafaftPlanHolderException)
	MakeException (ParafaftCompiledWithoutSinglePrecisionSupport)
	MakeException (ParafaftPlannerException)
	MakeException (FFTLibraryDoubleInitializationException)
	MakeException (FFTLibraryDecompositionMismatchException)
	MakeException (FFTTopologyException)
	MakeException (DimensionCountRecorderException)
	MakeException (DimensionCountRecorder_CoordinateSpaceException)
	MakeException (MomentumMultiplicityWrongSpaceConfirmation)
	MakeException (SpatialCoordinateConfigWrongSpaceConfirmation)
	MakeException (WaveNumberWrongSpaceConfirmation)
	MakeException (GetToolBoxException)
	MakeException (RandomGaussianFieldNegativeFrequencyException)
	MakeException (FieldValueGetterException)
	MakeException (FieldViewConfigWrongSpaceConfirmation)
	MakeException (FieldViewConfigMissingToolBox)
	MakeException (FieldViewFourierWrongSpaceConfirmation)
	MakeException (GhostBusterOrderException)
	MakeException (GhostBusterBoundsException)
	MakeException (GhostUpdaterException)
	MakeException (FileIOException)
	MakeException (LatticeParametersInconsistent) A class which holds physical paramteters of the lattice. Note that dx and kIr are equivalent only for isotropic lattices. For anisotropic, only one of th e two should be specified.
	MakeException (AveragerWrongSpace)
	MakeException (MaximumWrongSpace) A class which computes the maximum value of a getter.
	MakeException (RadialProjectionResultSizeException)
	MakeException (RadialProjectionResultFinalizationException)
	MakeException (RadialProjectionSingleQuantityException)
	MakeException (UnbinnedRadialProjectionResultFinalizationException)
	MakeException (MemoryBlockOutOfBoundsException)
	MakeException (LayoutStructWrongSizeException)
	MakeException (LayoutStructOutOfBoundsExcetion)
	MakeException (LayoutStructLocalSizeException)
	MakeException (LayoutStructLocalTransposedSizeException)
	MakeException (TranspositionMapOutOfBounds)
	MakeException (MemoryManagerAccessOutOfBounds)
	MakeException (InconsistentDomainSplitting)
	MakeException (InconsistentDimensions)
	MakeException (MPICartesianGroupException)
	MakeException (MPIAllReduceException)
	MakeException (MPISendReceiveException)
	MakeException (MPICommReferenceBookKeepingException)
	MakeException (MPIDomainSplitException)
	MakeException (MPIGuardInstantiationException)
	MakeException (FileReaderProblemInputFile)
	MakeException (ParameterParserMissingMandatory) The outside-world interface for parameter parsing. Pass your argc/argv, receive an object that parsed everything that you put on the command line interface, where 'everything' means that you pass arguments in the form:
	MakeException (ParameterParserMismatchSizes)
	MakeException (ParameterParserMismatchDefaultSizes)
	MakeException (ParameterParserDoesNotExist)
	MakeException (ParameterParserIsEmpty)
	MakeException (SessionGuardInstantiationException)
	MakeException (ConditionalFileStreamError)
	MakeException (FactorizationFailed)
	MakeException (KeccakHashBareClassReuseException)
	MakeException (RandomGaussianWrongCallOrderException)
	MakeException (EmptyModel)
	MakeException (NotTested)
	MakeException (PotentialDerivativeNotDefined)
	MakeException (NotEnoughChargesForThisCouplingsManager)
	MakeException (NotEnoughCouplingsForThisCouplingsManager)
	MakeException (DiffusionEvolverInvalid) A class that applies diffusion to the fields. Currently used to generate initial conditions of defect networks.
	MakeException (MoreThanOneDoublet)
	MakeException (EvolverTypeNotInEvolver) A class which interfaces the evolver, so we don't need to use pointers in the main.
	MakeException (InvalidEvolverTypeGW)
	MakeException (InvalidEvolverTypeAxion)
	MakeException (NotAnEvolverType)
	MakeException (NotPVEvolver)
	MakeException (NotVVEvolver)
	MakeException (ExtraMemoryNotAllocated)
	MakeException (PSTypeINotSupportedForNDIMDifferentFrom3)
	MakeException (NotAnICType) A namespace that collects different types to specify different initial conditions,.
	MakeException (SICNotImplemented)
	MakeException (U1ICNotImplemented)
	MakeException (UseHDF5ButNotCompiled)
	MakeException (FileAlreadyExistsError)
	MakeException (WrongPSType)
	MakeException (WrongPRJType)
	MakeException (RunParametersMissing)
	MakeException (RunParametersInconsistent)
void	NDLoop (const View & view, const Functor & functor) A utility to perform N-dimensional loops over views. As this is not optimized for performance, it should only be used in tests. Naturally, NDLoop is a sequential loop - to use parallelism make use of device::iteration utilities. However, it is CPU-only and has therefore its special use cases.
std::ostream &	PutToStream (std::ostream & stream, const T & vec) Simple outputing of arrays and vectors: not exposing as operator<<, because below we want to limit it to vectors and arrays, without needing to know the exact number of template parameters for this systems implementation of array and vector.
auto	Real (T && t) A class which get real parts of fields.
auto	Real (T && t)
auto	Real (T && t) Real part of a getter whose eval() returns a complex value (e.g. RandomGaussianField in Fourier space). Bridges it into the complex-field protocol first, so Real(f) == Real(asComplexField(f)).
auto	SU2DoubletWrap (A && pA, B && pB, C && pC, D && pD)
auto	SU2DoubletWrap (F && f)
auto	SU2GroupWrap (A && pA, B && pB, C && pC)
auto	SU2Wrap (const A & pA, const B & pB, const C & pC, const D & pD)
auto	SU2Wrap (const F & f)
StreamCacher	SayComplete (const char * fname, int line) Instantiate a container that eats up all the stream that you put in it, only locking the mutex and throwing up into std::cerr upon destruction. Provide the filename and line number of the place of invocation. Use the macro 'say' defined below.
ptrdiff_t	SetStacktracePtrToFileAddress () Posix's backtrace gives current memory addresses, which are good for runtime business, but not useful for finding source code locations. Need to convert that to file addresses, using this offset.
void	StacktracePlainptrs (std::array< void *, N > * result, int * addrlen) Templated size: just throw in your array and we fill it to at most its size. Plain backtrace version.
void	StacktracePlainptrs (std::array< void *, N > * result, int * addrlen) Templated size: just throw in your array and we fill it to at most its size. Libunwind (better!) version.
ptrdiff_t	StacktracePtrToFileAddress ()
constexpr const char *	StripPathFromFileName (const char * name) noexcept Performed by the compiler, if the const char* is a string at compile time.
std::pair< bool, std::string >	Throws (Lambda ll) A standalone function for testing of an exception is properly thrown. Returns a bool and a description.
constexpr const char *	TrailingZeroChar (const char * name) Performed by the compiler, if the const char* is a string at compile time.
auto	abs (const R & r)
auto	abs (const T & a) Exposing our newly defined absolute value operation to the world.
constexpr ZeroType	abs (ZeroType a)
constexpr OneType	abs (OneType a)
constexpr HalfType	abs (HalfType a)
auto	acos (T a) Exposing our newly defined acos operation to the world.
constexpr ZeroType	acos (OneType a) Specialize for possible unit input! acos(1) = 0.
auto	arg (T && t)
auto	arg (T && t)
auto	arg (R r, T t)
auto	arg2 (T && t) A class which returns the phase of a complex field, between -pi and pi.
auto	arg2 (T && t)
auto	arg2 (R r, T t)
auto	asComplexField (R && r)
ComplexFieldAsFourier< R >	asFourier (R && r)
auto	asinh (T a) Exposing our newly define exp operation to the world.
auto	average (T instance, SpaceStateType spaceType=GetGetReturnType< T >::isComplex ? SpaceStateType::Fourier :SpaceStateType::Configuration)
auto	average (T expr)
auto	average (T a)
auto	average (ZeroType a)
auto	backDiff (R pR, Tag< N > t)
constexpr auto	backDiff (R, Tag< N >)
constexpr auto	backDiff (R)
constexpr auto	binary_fold (BinaryOp && op, Tuple && tup, Function && func, Unity && unit)
constexpr auto	binary_fold_impl (BinaryOp && op, Tuple && tup, Function && func, Unity && unit, Tag<-1 > tg)
constexpr auto	binary_fold_impl (BinaryOp && op, Tuple && tup, Function && func, Unity && unit, Tag< Index > tg)
constexpr void	binary_for_each (Tuple1 && tuple1, Tuple2 && tuple2, F && f)
constexpr void	binary_for_each_impl (Tuple1 && tuple1, Tuple2 && tuple2, F && f, std::index_sequence< Indices... >)
auto	commutator (const R & r, const T & t)
auto	commutator (OneType r, const T & t)
auto	commutator (const R & r, OneType t)
auto	commutator (ZeroType r, const T & t)
auto	commutator (const R & r, ZeroType t)
auto	complexPhase (R && r)
auto	complexfieldaverage (T instance, SpaceStateType spaceType=IsComplexType< typename ComplexGetGetReturnType< T >::type > ? SpaceStateType::Fourier :SpaceStateType::Configuration)
auto	conj (const R & r)
auto	conj (const R & r)
auto	conj (const R & r)
auto	conj (const T & a) Exposing our newly define multiplication operation to the world.
constexpr ZeroType	conj (ZeroType a)
constexpr OneType	conj (OneType a)
constexpr HalfType	conj (HalfType a)
DEVICE_INLINE_FUNCTION constexpr void	constexpr_for (F && f) A compile-time for loop, which calls the lambda f of signature void(integer) for each index.
auto	cos (T a) Exposing our newly define exp operation to the world.
constexpr OneType	cos (ZeroType a) Specialize for possible zero input!
auto	cosh (T a) Exposing our newly define exp operation to the world.
constexpr OneType	cosh (ZeroType a) Specialize for possible zero input!
auto	createParams (int argc, char * argv)
auto	dag (const R & r)
auto	dagger (const R & r)
constexpr OneType	dagger (OneType)
constexpr ZeroType	dagger (ZeroType)
auto	dagger (const R & r)
auto	dagger (const SU2Dagger< R > & r)
auto	dagger (const SU2Multiplication< A, B > & m)
auto	dagger (const SU2Shifter< R, N... > & s)
auto	dagger (const SU2ShifterByOne< R, N > & s)
auto	dagger (const R & r)
auto	decay_tuple (T && t, std::index_sequence< Is... >)
auto	decay_tuple (T && t)
auto	derivatives (T && expr, R & others)
VectorDotter< R, T >	dot (R r, T t)
auto	electricField2 (R Es, Tag< 1 > t)
auto	electricField2 (R Es, Tag< 2 > t)
auto	electricField2 (R Es, Tag< 3 > t)
auto	electricField2 (R && Es)
auto	exp (const R & r)
auto	exp (T a) Exposing our newly define exp operation to the world.
constexpr OneType	exp (ZeroType a) Specialize for possible zero input!
auto	exp (const R & r)
auto	expinv (const R & r)
auto	explode (T && t, char) A class which flatten all directions of a composite object.
auto	explode (T && t, int)
auto	explode (T && t, std::index_sequence< Is... >)
auto	fieldStrength (R A, Tag< Mu > mu, Tag< Nu > nu) Returns the field strength tensor F_{mu,nu} = d_mu A_nu - d_nu A_mu, where A is a gauge field and d is a forward derivative, using a forward finite difference.
auto	fieldStrengthCtr (R A, Tag< Mu > mu, Tag< Nu > nu) Returns the field strength tensor F_{mu,nu} = d_mu A_nu - d_nu A_mu, where A is a gauge field and d is a forward derivative, using a central finite difference.
std::vector< typename std_atomic_type< NestedVec >::type >	flatten (const NestedVec & nested) A function which flattens a std::vector.
std::enable_if<< T >::value >::type	flatten_helper (const T & elem, std::vector< T > & flat)
std::enable_if< is_std_vector< T >::value >::type	flatten_helper (const T & nested, std::vector< typename std_atomic_type< T >::type > & flat)
auto	flatten_tuple (T && t, std::index_sequence< Is... >)
auto	flatten_tuple (T && t)
constexpr auto	fold_multiply (Tuple && tup, Function && func) Multiplies all the components of a tuple after applying func to them.
constexpr auto	fold_multiply (Tuple && tup) Multiplies all the components of a tuple.
constexpr auto	fold_multiply_impl (Tuple && tup, Function && func, Unit && unit, std::integer_sequence< int, INT... > iseq)
constexpr auto	fold_multiply_unit (Tuple && tup, Unit && unit) Multiplies all the components of a tuple after applying func to them, starting from unit.
constexpr void	for_each (Tuple && tuple, F && f)
constexpr void	for_each_impl (Tuple && tuple, F && f, std::index_sequence< Indices... >) A class which.
void	for_in_range (F && f) A function which implements a static for loop. Note that this for-loop is INCLUSIVE of the start AND end.
auto	forwDiff (R pR, Tag< N > t)
constexpr auto	forwDiff (R, Tag< N >)
constexpr auto	forwDiff (R)
auto	forwDij (R pR, Tag< N > t)
constexpr auto	forwDij (R)
auto	getAverager (T instance, SpaceStateType spaceType=GetGetReturnType< T >::isComplex ? SpaceStateType::Fourier :SpaceStateType::Configuration)
std::shared_ptr< FFTSessionGuard >	getFFTWSessionGuard (bool pVerbose=true)
std::vector< int >	getTypeIBinCounts (const device::Idx N)
GetVectorComponentHelper< N, R >	getVectorComponent (const R & pR, Tag< N >)
auto	heaviside (const R & r)
constexpr OneType	heaviside (ZeroType a) Specialize for possible zero input!
constexpr OneType	heaviside (OneType a) Specialize for possible unit input!
T	integrate (const std::vector< T > & vec, T dt)
auto	log (const R & r)
auto	log (T a) Exposing our newly define log operation to the world.
constexpr ZeroType	log (OneType a) Specialize for possible zero output!
auto	magneticField (R && As, Tag< 1 > t) A function to return the magnetic field from the gauge potential. Specialised to 3D. TODO: ND?
auto	magneticField (R && As, Tag< 2 > t)
auto	magneticField (R && As, Tag< 3 > t)
auto	magneticField (R && As)
auto	magneticField4 (R Bs, Tag< 1 > t) A function to get the average between the 4 links of the magnetic field from the gauge potential. Specialised to 3D.
auto	magneticField4 (R && Bs, Tag< 2 > t)
auto	magneticField4 (R && Bs, Tag< 3 > t)
auto	magneticField4 (R && Bs)
auto	magneticFieldCtr (R && As, Tag< 1 > t) A function to return the magnetic field from the gauge potential using centered finite derivatives. Specialised to 3D. TODO: ND?
auto	magneticFieldCtr (R && As, Tag< 2 > t)
auto	magneticFieldCtr (R && As, Tag< 3 > t)
auto	magneticFieldCtr (R && As)
device::array< T, N >	makeUniformArray (const T & value)
auto	make_flat_list (Args... args) A class which creates a flat tuple from potentially a list of composite objects.
auto	make_latinindices_list (Args... args)
auto	make_list (Args... args)
auto	make_list_from_array (std::array< T, N > arr)
int	make_list_from_array (std::array< T, 0 > arr)
constexpr auto	make_list_tag (F && f)
constexpr auto	make_list_tag (F && f)
auto	make_list_tag_impl (F && f, std::integer_sequence< int, I... > iseq) A class which.
auto	make_templatvector (Args... args)
auto	make_tuple_from (R && r)
auto	make_tuple_from (R && r)
constexpr auto	make_tuple_sequence ()
constexpr auto	make_tuple_sequence_helper (std::integer_sequence< T, I... >)
auto	make_tuple_tag (F && f)
auto	make_tuple_tag (F && f)
auto	make_tuple_tag_impl (F && f, std::integer_sequence< int, I... > iseq) Function that creates a tuple of (f(Tag<0>, ..., f(Tag<N>) ).
auto	make_vector (Args... args)
constexpr auto	make_vector_tag (F && f)
constexpr auto	make_vector_tag (F && f)
auto	make_vector_tag_impl (F && f, std::integer_sequence< int, I... > iseq)
auto	max (T instance, SpaceStateType spaceType=GetGetReturnType< T >::isComplex ? SpaceStateType::Fourier :SpaceStateType::Configuration)
auto	max (ZeroType a)
auto	multiplyTrace (const R & r, const T & t)
auto	multiplyTrace (const R & r, const T & t)
auto	multiplyTrace (const R & r, const T & t)
auto	neutDiff (R pR, Tag< N > t)
constexpr auto	neutDiff (R)
auto	neutDij (R pR, Tag< N > t)
constexpr auto	neutDij (R pR)
auto	nonabelianclover (const R & Us, Tag< Mu > mu, Tag< Nu > nu) A function that returns the clover discretization of non-abelian magnetic fields.
auto	norm (R r)
auto	norm2 (R && r)
auto	norm2 (const R & r) A class which computes the norm of a list.
auto	norm2 (R r)
auto	norm2 (const R & r)
constexpr bool	operator!= (Tag< M > t1, Tag< N > t2)
constexpr auto	operator""_c ()
auto	operator* (const R & r, const T & t)
auto	operator* (const R & r, const T & t)
auto	operator* (const R & r, const T & t)
auto	operator* (const R & r, const T & t)
auto	operator* (const R & r, const T & t)
auto	operator* (const R & r, const T & t)
auto	operator* (const R & r, const T & t)
auto	operator* (const R & r, const T & t)
auto	operator* (const R & r, const T & t)
auto	operator* (const R & r, const T & t)
auto	operator* (const R & r, const T & t)
auto	operator* (const R & r, const T & t) Exposing our newly define multiplication operation to the world.
auto	operator* (const R & r, Tag< N > n)
auto	operator* (Tag< N > n, const R & r)
constexpr auto	operator* (Tag< N > n, Tag< M > m)
constexpr ZeroType	operator* (ZeroType, ZeroType) Specialize for ZeroType *ZeroType .
ZeroType	operator* (const T &, ZeroType b) Specialize for possible zero input!
constexpr ZeroType	operator* (ZeroType a, const T &) Specialize for possible zero input!
constexpr auto	operator* (const T & a, const OneType b) Specialize for possible unit input!
constexpr auto	operator* (const OneType & a, const T & b) Specialize for possible unit input!
constexpr OneType	operator* (OneType a, OneType b) Specialize for possible unit input!
auto	operator* (const R & r, const T & t)
auto	operator* (const R & r, const T & t)
auto	operator* (const R & r, const T & t)
auto	operator* (const T & t, const R & r)
auto	operator* (const R & r, const T & t)
auto	operator* (R r, const T & t)
auto	operator* (const R & r, const T & t)
auto	operator* (const R & r, const T & t)
RadialProjectionResult< T >	operator* (R && func, const RadialProjectionResult< T > & obj)
RadialProjectionResult< T >	operator* (double scale, const RadialProjectionResult< T > & obj)
RadialProjectionResult< T >	operator* (float scale, const RadialProjectionResult< T > & obj)
RadialProjectionResult< T >	operator* (int scale, const RadialProjectionResult< T > & obj)
UnbinnedRadialProjectionResult< T >	operator* (R && func, const UnbinnedRadialProjectionResult< T > & obj)
UnbinnedRadialProjectionResult< T >	operator* (double scale, const UnbinnedRadialProjectionResult< T > & obj)
UnbinnedRadialProjectionResult< T >	operator* (float scale, const UnbinnedRadialProjectionResult< T > & obj)
UnbinnedRadialProjectionResult< T >	operator* (int scale, const UnbinnedRadialProjectionResult< T > & obj)
Tag< M *N >	operator* (Tag< M > t1, Tag< N > t2)
auto	operator+ (const R & r, const T & t)
auto	operator+ (const R & r, const T & t)
auto	operator+ (const R & r, const T & t)
auto	operator+ (const R & r, const T & t)
auto	operator+ (const R & r, const T & t)
auto	operator+ (const R & r, const T & t)
constexpr auto	operator+ (const ZeroType a, const ZeroType b) Specialize for possible zero input!
constexpr OneType	operator+ (const HalfType a, const HalfType b) Specialize for possible half input!
T	operator+ (const ZeroType a, const T b) Specialize for possible zero input! Need to disable one of these for two ZeroTypes as input.
T	operator+ (const T b, const ZeroType a) Specialize for possible zero input! Need to disable one of these for two ZeroTypes as input.
auto	operator+ (const R & r, const T & t)
auto	operator+ (const R & r, const T & t)
RadialProjectionResult< T >	operator+ (const RadialProjectionResult< T > & a, const RadialProjectionResult< T > & b)
UnbinnedRadialProjectionResult< T >	operator+ (const UnbinnedRadialProjectionResult< T > & a, const UnbinnedRadialProjectionResult< T > & b)
Tag< M+N >	operator+ (Tag< M > t1, Tag< N > t2)
auto	operator- (const R & r, const T & t)
auto	operator- (const R & r, const T & t)
auto	operator- (const R & r, const T & t)
auto	operator- (const R & r, const T & t)
auto	operator- (const R & r)
auto	operator- (const R & r, const T & t)
Operators::Subtraction< R, T >	operator- (const R & r, const T & t)
T &	operator- (T && a, ZeroType b) Specialize for possible zero input!
auto	operator- (ZeroType a, const T & b) Specialize for possible zero input! Need to disable one of these for two ZeroTypes as input.
auto	operator- (T && a, Operators::UnaryMinus< S > && b) Specialize for unary minus.
constexpr HalfType	operator- (const OneType a, const HalfType b) Specialize for possible half input!
auto	operator- (HalfType a, OneType b) Specialize for possible half input!
constexpr auto	operator- (OneType a, OneType b) Specialize for possible OneType __OneType input.
auto	operator- (const T & a) Exposing our newly defined subtraction operation to the world.
constexpr ZeroType	operator- (ZeroType a) Specialize for possible zero input!
auto	operator- (Operators::UnaryMinus< Operators::UnaryMinus< T > > && a) Specialize for double minus signs: -(-(-x)) collapses to -x. The argument a == -(-x) == +x, so -a == -x, which is exactly the inner UnaryMinus<T> node a.mR.
auto	operator- (const R & r, const T & t)
auto	operator- (const R & r, const T & t)
Tag< M - N >	operator- (Tag< M > t1, Tag< N > t2)
Tag<-M >	operator- (Tag< M > t1)
auto	operator/ (const R & r, const T & t)
auto	operator/ (const R & r, const T & t)
auto	operator/ (const R & r, const T & t)
auto	operator/ (const R & r, const T & t) Exposing our newly define multiplication operation to the world.
constexpr T	operator/ (const T & a, OneType b) Specialize for possible unit input! Simplify derivatives for example.
constexpr auto	operator/ (const ZeroType & a, const T &) Specialize for possible zero input! Need to disable one of these for two ZeroTypes as input.
auto	operator/ (const T & t, const R & r)
constexpr bool	operator< (Tag< M > t1, Tag< N > t2)
constexpr bool	operator< (Tag< M > t1, Tag< N > t2)
std::ostream &	operator<< (std::ostream & ostream, const T & obj) Enable simple operator<< for all objects with a toString method.
std::ostream &	operator<< (std::ostream & ostream, SpaceStateType st)
std::ostream &	operator<< (std::ostream & ostream, const HermitianRedundancy & hr)
std::ostream &	operator<< (std::ostream & stream, const device::array< T, N > & vec)
std::ostream &	operator<< (std::ostream & stream, const std::pair< T, K > & p)
std::ostream &	operator<< (std::ostream & stream, const C & vec)
std::ostream &	operator<< (std::ostream & os, const Tag< N > & t)
constexpr bool	operator<= (Tag< M > t1, Tag< N > t2)
constexpr bool	operator<= (Tag< M > t1, Tag< N > t2)
constexpr bool	operator== (Tag< M > t1, Tag< N > t2)
constexpr bool	operator> (Tag< M > t1, Tag< N > t2)
constexpr bool	operator> (Tag< M > t1, Tag< N > t2)
constexpr bool	operator>= (Tag< M > t1, Tag< N > t2)
constexpr bool	operator>= (Tag< M > t1, Tag< N > t2)
std::istream &	operator>> (std::istream & in, EvolverType & eType)
constexpr long long	parse (const char(&) arr)
auto	plaq (R Us, Tag< Mu > mu, Tag< Nu > nu) A class which defines plaquette operator.
auto	plaqBack (const R & Us, Tag< Mu > mu, Tag< Nu > nu) A class which implemets a backward plaquette. Useful in equations of motions for example.
auto	pow (const R & r, const T & t)
auto	pow (const R & r)
auto	pow (const R & r, const T & t)
constexpr ZeroType	pow (ZeroType)
constexpr OneType	pow (const T & a, ZeroType b)
constexpr auto	pow (ZeroType a, const T &) Specialize for possible zero input! Need to disable one of these for two ZeroTypes as input.
auto	pow (const R & r)
auto	pow (const R & r)
constexpr auto	pow (const T & a) Specialize for possible zero input!
T	pow (const T & a) Specialize for possible one input!
constexpr DEVICE_INLINE_FUNCTION NumberType	powr (const NumberType x) A compile-time evaluatable power function for whole number exponents. This implementation generates some rather efficient instructions, see ( https://godbolt.org/z/vT56bb1nx ).
auto	projectChiralU1Type1 (const Model & model, Tag< U1 >, Tag< C >, bool sign, bool AorE)
auto	projectGWType1 (const Model & model)
auto	projectGWType2 (const Model & model)
auto	projectGWType3 (const Model & model)
RadialProjector< T >	projectRadially (T instance, SpaceStateType spaceType, device::memory::host_ptr< MemoryToolBox< NDim > > pToolBox, bool useBinCentralValues=false)
RadialProjector< T >	projectRadially (T instance, bool useBinCentralValues=false)
RadialProjector< T >	projectRadiallyFourier (T instance, bool useBinCentralValues=false)
DEVICE_INLINE_FUNCTION auto	reverse_array (const device::array< Arg, N > & array, std::index_sequence< Is... >)
DEVICE_INLINE_FUNCTION auto	reverse_array (const device::array< Arg, N > & array)
DEVICE_INLINE_FUNCTION auto	reverse_tuple (const device::tuple< Args... > & tuple, std::index_sequence< Is... >)
DEVICE_INLINE_FUNCTION auto	reverse_tuple (const device::tuple< Args... > & tuple)
auto	safeDivide (const R & r, const T & t)
auto	safeSqrt (const R & r)
auto	scalar_prod (const R & r, const T & t)
auto	scalar_prod (const R & r, ZeroType t)
auto	scalar_prod (ZeroType t, const R & r)
auto	sh1 (const R & pR)
auto	sh1 (const R & pR)
auto	shift (const R & pR)
auto	shift (const R & pR)
auto	shift (const R & pR, Tag< N > t)
auto	shift (const R & r)
auto	shift (const R & pR, const Tag< N > & t)
auto	shift (const R & pR)
auto	shift (const R & pR)
auto	shift (const R & pR, Tag< N > t)
auto	shift (const R & pR)
auto	shift (const R & pR)
auto	shift (const R & pR, Tag< N > t)
constexpr OneType	shift (OneType)
constexpr OneType	shift (OneType, Tag< N >)
constexpr ZeroType	shift (ZeroType)
constexpr ZeroType	shift (ZeroType, Tag< N >)
auto	shift (const R & pR)
auto	shift (const R & pR)
auto	shift (const R & pR, Tag< N > t)
auto	shift (const R & pR)
auto	shift (const R & pR)
auto	shift (const R & pR, Tag< N > t)
auto	shifted_index_sequence (std::index_sequence< I... >) Use as shifted_index_sequence<SHIFT>(std::make_index_sequence<N>{}) To get an index sequence<SHIFT,SHIFT+1,...,SHIFT+N-1>
auto	sin (T a) Exposing our newly define exp operation to the world.
constexpr ZeroType	sin (ZeroType a) Specialize for possible zero input!
auto	sinh (T a) Exposing our newly define exp operation to the world.
constexpr ZeroType	sinh (ZeroType a) Specialize for possible zero input!
ListPower< R, HalfType >	sqrt (const R & r)
auto	sqrt (T a)
constexpr ZeroType	sqrt (ZeroType a) Specialize for possible zero input!
constexpr OneType	sqrt (OneType a) Specialize for possible unit input!
auto	su2average (T instance, SpaceStateType spaceType=IsComplexType< typename SU2GetGetReturnType< T >::type > ? SpaceStateType::Fourier :SpaceStateType::Configuration)
auto	su2dotter (const R & r, const T & t)
auto	su2doubletaverage (T instance, SpaceStateType spaceType=IsComplexType< typename SU2DoubletGetGetReturnType< T >::type > ? SpaceStateType::Fourier :SpaceStateType::Configuration)
constexpr auto	sum_in_range (F && func) A function which applies + to the results of func(Tag<i>()) for i in [begin, end).
constexpr auto	sum_in_range_impl (F && func, std::integer_sequence< int, INT... > iseq)
SymTracelessFieldAsFourier< R >	symTracelessFieldAsFourier (R && r)
consteval int	tag_value (Tag< N >)
auto	tanh (T a) Exposing our newly define exp operation to the world.
constexpr ZeroType	tanh (ZeroType a) Specialize for possible zero input!
auto	toSU2 (R r)
constexpr int	to_int (char c) A class which implements a litteral to create tags, comes from Boost Hana.
std::string	to_string (EvolverType eType)
constexpr auto	total (Tuple && tup, Function && func) Sums all the components of a tuple after applying func to them.
constexpr auto	total (Tuple && tup) Sums all the components of a tuple.
constexpr auto	total_impl (Tuple && tup, F && func, std::integer_sequence< int, INT... > iseq)
auto	trace (R && r) A function which takes the trace of su2 matrices.
constexpr auto	trace (ZeroType r)
DEVICE_INLINE_FUNCTION constexpr auto	tuple_add_to_nth (const device::tuple< IDX... > & tt)
DEVICE_INLINE_FUNCTION constexpr auto	tuple_add_to_nth_mod (device::tuple< IDX... > & tt) Pass a tuple of indices and add the second argument to the n-th value of the tuple.
DEVICE_INLINE_FUNCTION constexpr auto	tuple_first (const device::tuple< Head, Tail... > & t) Returns the first i elements of the given tuple t.
DEVICE_INLINE_FUNCTION constexpr auto	tuple_last (const device::tuple< Head, Tail... > & t) Returns the last i elements of the given tuple t.
auto	wallAverager (T instance, SpaceStateType spaceType=SpaceStateType::Configuration)
auto	wallAverager (ZeroType a)

Public Static Functions

Type	Name
auto	getComponent (T && t, Tag< I > i) A class which returns imaginary part of a fields or symmetric-traceless number.
auto	getComponent (T && t, Tag< I > i)
auto	getComponent (T && t, Tag< I > i)
auto	getComponent (T && t, Tag< I > i)
auto	getComponent (T && t, Tag< I > i, Tag< J > j)
auto	getComponent (T && t, Tag< I > i, Tag< J > j)
auto	getComponent (T && t, Tag< I > i, Tag< J > j)
auto	getComponent (T && t, Tag< I > i, Tag< J > j)
std::vector< std::shared_ptr< FFTSessionGuard > >	getFFTSessionGuards (bool pVerbose=true)

Detailed Description

to get epsilons for various types

Public Types Documentation

typedef AveragerReturnType

using TempLat::AveragerReturnType = typedef std::conditional_t<std::is_integral_v<T> || std::is_floating_point_v<T>, double, T>;

---

typedef BDPhasePi2A

using TempLat::BDPhasePi2A = typedef BDPhaseHelper<T, NDim, true>;

---

typedef BDPhasePi2E

using TempLat::BDPhasePi2E = typedef BDPhaseHelper<T, NDim, false>;

---

enum CANONICALTYPE

enum TempLat::CANONICALTYPE {
    AMPLITUDE,
    MOMENTUM
};

---

typedef Collection

using TempLat::Collection = typedef typename CollectionSelector<Q, T, NDim, ISMOMENTUM, N, SHIFT, N == 0>::type;

---

typedef Concat_t

using TempLat::Concat_t = typedef typename Concat<S1, S2>::type;

---

enum EvolverType

An enum, listing all available evolver types:

enum TempLat::EvolverType {
    LF,
    VV2,
    VV4,
    VV6,
    VV8,
    VV10,
    VV6_2,
    RK2,
    RK3_3,
    RK3_4,
    RK4_5,
    PV2,
    PV4,
    PV6,
    PV8,
    PV10,
    PV6_2
};

• LF: leapfrog
• VV2: velocity verlet, order 2
• VV4: velocity verlet, order 4
• VV6: velocity verlet, order 6
• VV8: velocity verlet, order 8
• VV10: velocity verlet, order 10
• VV6_2: alternative scheme for velocity verlet order 6 (see documentation)
• PV2: position verlet, order 2
• PV4: position verlet, order 4
• PV6: position verlet, order 6
• PV8: position verlet, order 8
• PV10: position verlet, order 10
• PV6_2: alternative scheme for position verlet order 6 (see documentation)
• RK2: Runge-Kutta order 2
• RK3_3: 3rd order 3 stages low storage Runge-Kutta
• RK3_4: 3rd order 4 stages low storage Runge-Kutta
• RK4_5: 4th order 5 stages low storage Runge-Kutta

---

enum FFTBackendTag

A class which sets up the interface with the appropriate FFT library. Once you have implemented the FFTLibraryInterface for your library, add it to the logic here.

enum TempLat::FFTBackendTag {
    Parafaft,
    KokkosFFT,
    FFTW
};

Unit test: ctest -R test-fftlibraryselector

Which FFT backend a given runtime setup resolves to.

---

typedef FourierSite

using TempLat::FourierSite = typedef WaveNumber<NDim>;

---

enum HermitianPartnersMode

enum TempLat::HermitianPartnersMode {
    none,
    fftw
};

---

enum HermitianRedundancy

Tracks which entries in the layout carry redundant information, and if so, what information. This, again, assumes FFTW layout.

enum TempLat::HermitianRedundancy {
    none,
    negativePartner,
    positivePartner,
    realValued
};

• none: the complex value at this wavenumber has no redundancy, and can take any value.
• negativePartner: the value at this wavenumber is the complex conjugate of another value in the globalSpace, and we chose that this partner is the negative one.
• positivePartner: well, you guess.
• realValued: the complex value at this wavenumber must have zero imaginary part.

Unit test: ctest -R test-hermitianredundancy

---

typedef IsComposite

using TempLat::IsComposite = typedef IsCompositeHelper<R, tuple_size<decltype(std::remove_reference<R>::type::Getter::get( std::declval<R &>(), std::declval<Tag<0> >()))>::value>;

---

typedef MakeSeqImplTagList_t

using TempLat::MakeSeqImplTagList_t = typedef typename TagListHelper<Start, End>::type;

---

typedef MakeSeqImpl_t

using TempLat::MakeSeqImpl_t = typedef typename CollectionHelper<Q, T, NDim, ISMOMENTUM, Start, End>::type;

---

typedef MakeSeqTagList_t

using TempLat::MakeSeqTagList_t = typedef typename TagListHelper<0, N - 1>::type;

---

typedef MakeSeq_t

using TempLat::MakeSeq_t = typedef typename CollectionHelper<Q, T, NDim, ISMOMENTUM, 0, N - 1>::type;

---

typedef ParaFaFT_Backend

using TempLat::ParaFaFT_Backend = typedef parafaft::FFTWBackend<T>;

---

enum ParameterImportance

enum TempLat::ParameterImportance {
    Important,
    Normal
};

---

enum Parity

enum TempLat::Parity {
    Even = 0,
    Odd = 1
};

---

typedef RandomGaussianField

using TempLat::RandomGaussianField = typedef RandomGaussianFieldHelper<T, NDim, SpaceStateType::Fourier, false, false>;

@vocab-summary Gaussian random field generated directly in Fourier space. @vocab-tags Field, Fourier

---

typedef RandomGaussianFieldConfig

A Gaussian random field directly in configuration space: independent real N(0,1) white noise per lattice site (flat spectrum). NOT equivalent to drawing in Fourier space and transforming unless.

using TempLat::RandomGaussianFieldConfig = typedef RandomGaussianFieldHelper<T, NDim, SpaceStateType::Configuration, false, false>;

@vocab-summary Gaussian random field in configuration space: an independent normal draw per site. The counter-based generator makes each site independent of every other, so results are identical whatever the decomposition. the target spectrum is flat for a specific P(k), assign in Fourier space instead.

---

typedef RandomRayleighField

using TempLat::RandomRayleighField = typedef RandomGaussianFieldHelper<T, NDim, SpaceStateType::Fourier, true, false>;

@vocab-summary Fourier-space field with Rayleigh-distributed amplitude and uniform random phase. @vocab-tags Field, Fourier

---

typedef RandomUniformUnitaryField

using TempLat::RandomUniformUnitaryField = typedef RandomGaussianFieldHelper<T, NDim, SpaceStateType::Fourier, false, true>;

@vocab-summary Fourier-space field of unit modulus with uniformly random phase. @vocab-tags Field, Fourier

---

enum SpaceStateType

An enum for passing the right space type, all while having the compiler type check it.

enum TempLat::SpaceStateType {
    Configuration,
    Fourier,
    undefined
};

---

typedef TagList

using TempLat::TagList = typedef typename TagListHelper<START, END>::type;

---

typedef TupleMaker

using TempLat::TupleMaker = typedef TupleMakerHelper<R, IsComposite<R>::value>;

---

typedef U1Field

A U(1) group-valued field.

using TempLat::U1Field = typedef ComplexField<T, NDim>;

A U(1) group element is a complex number of unit modulus, so a U(1) field is simply a ComplexField: the group product is complex multiplication, the inverse is conj() / dagger(), and the exponential map is complexPhase() (see u1exponential.h).

Unlike SU2Field there is no unitarize() method. Links stay on the group by construction when they are updated multiplicatively through the exponential map,

U = complexPhase(dt * E) * U; // U <- e^{i dt E} U, exactly unit modulus

rather than additively (U += ... would leave the group). See bench-u1_evolution for a complete time-evolution example.

Unit test: ctest -R test-u1field

@vocab-summary A single \(U(1)\) link \(U\_i = e^{\mathrm{i} A\_i}\) for fixed \(i\). An alias of ComplexField, because a \(U(1)\) group element is a unit-modulus complex number: the group product is complex multiplication and the inverse is conj(). @vocab-signature U1Field<T, NDim> u("u", toolBox); @vocab-tags ComplexField

---

typedef VectorField

A class which Field collections. Allows to have vector fields, index starting from one.

using TempLat::VectorField = typedef FieldCollection<Arg, GetNDim::get<Arg>(), flatAssign, 1>;

Unit test: ctest -R test-vectorfield3d

@vocab-summary A vector-valued field — one component per spatial dimension, indexed from 1. The natural type for a gauge link \(U\_\mu\). @vocab-signature VectorField<FieldType> Us("Us", toolBox); @vocab-tags Collection

---

Public Functions Documentation

function AlmostEqual

we are comparing computed floats, so allow for some epsilon

template<typename T1, typename T2, typename T3>
DEVICE_FUNCTION bool TempLat::AlmostEqual (
    const T1 & a,
    const T2 & b,
    const T3 & epsilon=std::sqrt(std::numeric_limits< T3 >::epsilon())
) 

---

function AlmostEqual

overload for complex values. __

template<typename T>
DEVICE_FUNCTION bool TempLat::AlmostEqual (
    const complex< T > & a,
    const complex< T > & b,
    const T epsilon=std::sqrt(std::numeric_limits< T >::epsilon())
) 

---

function AlmostEqual

overload for arrays

template<typename T, size_t N>
DEVICE_FUNCTION bool TempLat::AlmostEqual (
    const std::array< T, N > & a,
    const std::array< T, N > & b,
    const T epsilon=std::sqrt(std::numeric_limits< T >::epsilon())
) 

---

function B4NA

template<typename R>
auto TempLat::B4NA (
    const R & Us,
    Tag < 1 >
) 

@vocab-summary Non-abelian magnetic field component \(B\_i\) from the clover field strength. @vocab-signature B4NA(Us, i)

---

function B4NA

template<typename R>
auto TempLat::B4NA (
    const R & Us,
    Tag < 2 >
) 

---

function B4NA

template<typename R>
auto TempLat::B4NA (
    const R & Us,
    Tag < 3 >
) 

---

function BackwardCovariantDerivative

A class which.

template<size_t dim, class... Args>
auto TempLat::BackwardCovariantDerivative (
    Args... args
) 

Unit test: ctest -R test-backwardcovariantderivative

@vocab-summary Backward gauge-covariant derivative of a scalar: the backward difference with the scalar parallel-transported by the daggered link. Takes any number of gauge vectors followed by the scalar, so a field charged under several groups is written in one call. @vocab-signature BackwardCovariantDerivative<dim>(Us..., scalar)

---

function CDemangle

inline void TempLat::CDemangle (
    std::ostream & stream,
    char * start
) 

---

function CField

template<typename T, size_t NDim>
auto TempLat::CField (
    Field < T, NDim > f1,
    Field < T, NDim > f2
) 

@vocab-summary Bundles two existing real Fields into one complex field, sharing their memory rather than copying it. @vocab-signature CField(re, im)

---

function CenteredCovariantDerivative

A class which computes centered covariant derivatives.

template<size_t dim, class... Args>
auto TempLat::CenteredCovariantDerivative (
    Args... args
) 

Unit test: ctest -R test-centeredcovariantderivative

@vocab-summary Centred gauge-covariant derivative, accurate to \(O(dx^2)\). Takes the gauge vectors followed by the scalar. @vocab-signature CenteredCovariantDerivative<dim>(Us..., scalar)

---

function CenteredCovariantDerivativeO4

A class which computes a O(dx^4) discrete covariant derivative.

template<size_t dim, class... Args>
auto TempLat::CenteredCovariantDerivativeO4 (
    Args... args
) 

Unit test: ctest -R test-centeredcovariantderivativeo4

@vocab-summary Centred gauge-covariant derivative on a five-point stencil, accurate to \(O(dx^4)\). @vocab-signature CenteredCovariantDerivativeO4<dim>(Us..., scalar)

---

function CenteredDerivative

template<size_t dim, class T>
auto TempLat::CenteredDerivative (
    T t
) 

@vocab-summary The ungauged centred derivative — CenteredCovariantDerivative with no links.

---

function CenteredDerivativeO4

template<size_t dim, class T>
auto TempLat::CenteredDerivativeO4 (
    T t
) 

@vocab-summary The ungauged \(O(dx^4)\) centred derivative.

---

function Complexify

template<typename R, typename T>
ComplexFieldWrapper < R, T > TempLat::Complexify (
    const R & r,
    const T & t
) 

@vocab-summary Builds a complex expression from a real and an imaginary expression. Lightweight: it stores nothing and owns no memory. @vocab-signature Complexify(re, im)

---

function ConstructHerm

template<typename R11, typename R12, typename R13, typename R22, typename R23, typename R33>
HermWrapper < R11, R12, R13, R22, R23, R33 > TempLat::ConstructHerm (
    const R11 & r11,
    const R12 & r12,
    const R13 & r13,
    const R22 & r22,
    const R23 & r23,
    const R33 & r33
) 

@vocab-summary Builds a hermitian \(3\times3\) matrix expression from its upper triangle; the lower triangle is the conjugate. @vocab-signature ConstructHerm(h11, h12, h13, h22, h23, h33) @vocab-tags Herm3x3

---

function ConstructMatrix3x3

template<typename R11, typename R12, typename R13, typename R21, typename R22, typename R23, typename R31, typename R32, typename R33>
MatrixWrapper < R11, R12, R13, R21, R22, R23, R31, R32, R33 > TempLat::ConstructMatrix3x3 (
    const R11 & r11,
    const R12 & r12,
    const R13 & r13,
    const R21 & r21,
    const R22 & r22,
    const R23 & r23,
    const R31 & r31,
    const R32 & r32,
    const R33 & r33
) 

@vocab-summary Builds a general \(3\times3\) matrix expression, given row by row. Entries set to ZeroType are pruned from the tree at compile time. @vocab-signature ConstructMatrix3x3(m11, m12, m13, m21, m22, m23, m31, m32, m33)

---

function ConstructSym

template<typename R11, typename R12, typename R13, typename R22, typename R23, typename R33>
SymWrapper < R11, R12, R13, R22, R23, R33 > TempLat::ConstructSym (
    const R11 & r11,
    const R12 & r12,
    const R13 & r13,
    const R22 & r22,
    const R23 & r23,
    const R33 & r33
) 

@vocab-summary Builds a symmetric \(3\times3\) matrix expression from its upper triangle. @vocab-signature ConstructSym(s11, s12, s13, s22, s23, s33) @vocab-tags Sym3x3

---

function ConstructSymTraceless

template<typename R0, typename R1, typename R2, typename R3, typename R4, typename R5>
SymTracelessWrapper < R0, R1, R2, R3, R4, R5 > TempLat::ConstructSymTraceless (
    const R0 & r0,
    const R1 & r1,
    const R2 & r2,
    const R3 & r3,
    const R4 & r4,
    const R5 & r5
) 

@vocab-summary Builds a symmetric \(3\times3\) expression whose trace is subtracted on evaluation, so the result is traceless by construction. @vocab-signature ConstructSymTraceless(t11, t12, t13, t22, t23, t33) @vocab-tags SymTraceless

---

function DiracDelta

Exposing our newly define multiplication operation to the world.

template<typename T>
Operators::DiracDeltaFunction < T > TempLat::DiracDelta (
    const T & a
) 

@vocab-summary Discrete Dirac delta: the largest representable value where the operand is exactly zero, and zero elsewhere. Exists so that the derivative of heaviside has a name; it is not a distribution you can integrate.

---

function DoesNotThrow

A helper for negating Throws.

template<typename Exception, typename Lambda>
auto TempLat::DoesNotThrow (
    Lambda ll
) 

---

function ExceptionArgumentUnpacker

Recursion stopper for helper function for unpacking the variadic arguments of the Exception constructor.

inline void TempLat::ExceptionArgumentUnpacker (
    std::stringstream & stream
) 

---

function ExceptionArgumentUnpacker

Helper function for unpacking the variadic arguments of the Exception constructor.

template<typename T, typename... Args>
inline void TempLat::ExceptionArgumentUnpacker (
    std::stringstream & stream,
    T t,
    Args... args
) 

---

function Grad2

template<size_t NDim_, typename R>
auto TempLat::Grad2 (
    R pR
) 

@vocab-summary Squared norm of the forward gradient, \((\nabla\phi)^2\) — the gradient energy term, as one fused expression.

---

function Grad2

template<size_t NDim_, typename R>
constexpr auto TempLat::Grad2 (
    R
) 

---

function Imag

A class which returns imaginary part of a fields or complex number.

template<class T>
auto TempLat::Imag (
    T && t
) 

Unit test: ctest -R test-imag

@vocab-summary Imaginary part of a complex field or complex number.

---

function Imag

template<class T>
auto TempLat::Imag (
    T && t
) 

---

function Imag

Imaginary part of a getter whose eval() returns a complex value. Bridges it into the complex-field protocol first, so Imag(f) == Imag(asComplexField(f)).

template<class T>
auto TempLat::Imag (
    T && t
) 

---

function IsEqual

consteval bool TempLat::IsEqual (
    auto i,
    auto j
) 

---

function IsLess

consteval bool TempLat::IsLess (
    auto i,
    auto j
) 

---

function IsLessOrEqual

consteval bool TempLat::IsLessOrEqual (
    auto i,
    auto j
) 

---

function IsMore

consteval bool TempLat::IsMore (
    auto i,
    auto j
) 

---

function IsMoreOrEqual

consteval bool TempLat::IsMoreOrEqual (
    auto i,
    auto j
) 

---

function LatForwardGrad

template<size_t NDim_, typename R>
auto TempLat::LatForwardGrad (
    R pR
) 

@vocab-summary Forward gradient, as a vector expression with one forwDiff component per dimension.

---

function LatLapl

template<size_t NDim_, typename R>
auto TempLat::LatLapl (
    const R & r
) 

---

function LatLapl

template<size_t NDim_, typename R>
auto TempLat::LatLapl (
    R pR
) 

@vocab-summary Lattice Laplacian: the standard \(2d+1\)-point stencil, using the operand's own \(dx\). Applied component-wise to a collection. @vocab-signature LatLapl(expr) @vocab-primary

---

function LatLapl

template<size_t NDim_, typename R>
constexpr auto TempLat::LatLapl (
    R
) 

---

function MPITypeSelect

A bunch of compile-time templates for getting the right MPI constants for your type.

template<typename T>
constexpr MPI_Datatype TempLat::MPITypeSelect () 

Unit test: ctest -R test-mpitypeconstants

or without having to define a dummy variable to pass on, how about some templates:

---

function MakeException

TempLat::MakeException (
    FFTWHermitianPartnersWrongSizeException
) 

---

function MakeException

TempLat::MakeException (
    FFTWMPISendrecvCountOverflowException
) 

---

function MakeException

TempLat::MakeException (
    FFTWCompiledWithoutSinglePrecisionSupport
) 

---

function MakeException

TempLat::MakeException (
    KokkosFFTMemoryLayoutException
) 

---

function MakeException

TempLat::MakeException (
    KokkosFFTPlannerException
) 

---

function MakeException

TempLat::MakeException (
    ParafaftMemoryLayoutException
) 

---

function MakeException

TempLat::MakeException (
    ParafaftPlanHolderException
) 

---

function MakeException

TempLat::MakeException (
    ParafaftCompiledWithoutSinglePrecisionSupport
) 

---

function MakeException

TempLat::MakeException (
    ParafaftPlannerException
) 

---

function MakeException

TempLat::MakeException (
    FFTLibraryDoubleInitializationException
) 

---

function MakeException

TempLat::MakeException (
    FFTLibraryDecompositionMismatchException
) 

---

function MakeException

TempLat::MakeException (
    FFTTopologyException
) 

---

function MakeException

TempLat::MakeException (
    DimensionCountRecorderException
) 

---

function MakeException

TempLat::MakeException (
    DimensionCountRecorder_CoordinateSpaceException
) 

---

function MakeException

TempLat::MakeException (
    MomentumMultiplicityWrongSpaceConfirmation
) 

---

function MakeException

TempLat::MakeException (
    SpatialCoordinateConfigWrongSpaceConfirmation
) 

---

function MakeException

TempLat::MakeException (
    WaveNumberWrongSpaceConfirmation
) 

---

function MakeException

TempLat::MakeException (
    GetToolBoxException
) 

---

function MakeException

TempLat::MakeException (
    RandomGaussianFieldNegativeFrequencyException
) 

---

function MakeException

TempLat::MakeException (
    FieldValueGetterException
) 

---

function MakeException

TempLat::MakeException (
    FieldViewConfigWrongSpaceConfirmation
) 

---

function MakeException

TempLat::MakeException (
    FieldViewConfigMissingToolBox
) 

---

function MakeException

TempLat::MakeException (
    FieldViewFourierWrongSpaceConfirmation
) 

---

function MakeException

TempLat::MakeException (
    GhostBusterOrderException
) 

---

function MakeException

TempLat::MakeException (
    GhostBusterBoundsException
) 

---

function MakeException

TempLat::MakeException (
    GhostUpdaterException
) 

---

function MakeException

TempLat::MakeException (
    FileIOException
) 

---

function MakeException

A class which holds physical paramteters of the lattice. Note that dx and kIr are equivalent only for isotropic lattices. For anisotropic, only one of th e two should be specified.

TempLat::MakeException (
    LatticeParametersInconsistent
) 

Unit test: ctest -R test-latticeparameters

---

function MakeException

TempLat::MakeException (
    AveragerWrongSpace
) 

---

function MakeException

A class which computes the maximum value of a getter.

TempLat::MakeException (
    MaximumWrongSpace
) 

Unit test: ctest -R test-maximum

---

function MakeException

TempLat::MakeException (
    RadialProjectionResultSizeException
) 

---

function MakeException

TempLat::MakeException (
    RadialProjectionResultFinalizationException
) 

---

function MakeException

TempLat::MakeException (
    RadialProjectionSingleQuantityException
) 

---

function MakeException

TempLat::MakeException (
    UnbinnedRadialProjectionResultFinalizationException
) 

---

function MakeException

TempLat::MakeException (
    MemoryBlockOutOfBoundsException
) 

---

function MakeException

TempLat::MakeException (
    LayoutStructWrongSizeException
) 

---

function MakeException

TempLat::MakeException (
    LayoutStructOutOfBoundsExcetion
) 

---

function MakeException

TempLat::MakeException (
    LayoutStructLocalSizeException
) 

---

function MakeException

TempLat::MakeException (
    LayoutStructLocalTransposedSizeException
) 

---

function MakeException

TempLat::MakeException (
    TranspositionMapOutOfBounds
) 

---

function MakeException

TempLat::MakeException (
    MemoryManagerAccessOutOfBounds
) 

---

function MakeException

TempLat::MakeException (
    InconsistentDomainSplitting
) 

---

function MakeException

TempLat::MakeException (
    InconsistentDimensions
) 

---

function MakeException

TempLat::MakeException (
    MPICartesianGroupException
) 

---

function MakeException

TempLat::MakeException (
    MPIAllReduceException
) 

---

function MakeException

TempLat::MakeException (
    MPISendReceiveException
) 

---

function MakeException

TempLat::MakeException (
    MPICommReferenceBookKeepingException
) 

---

function MakeException

TempLat::MakeException (
    MPIDomainSplitException
) 

---

function MakeException

TempLat::MakeException (
    MPIGuardInstantiationException
) 

---

function MakeException

TempLat::MakeException (
    FileReaderProblemInputFile
) 

---

function MakeException

The outside-world interface for parameter parsing. Pass your argc/argv, receive an object that parsed everything that you put on the command line interface, where 'everything' means that you pass arguments in the form:

TempLat::MakeException (
    ParameterParserMissingMandatory
) 

a=1 b=2 c=3

The special keyword 'input' takes a filename as value, pointing to a file in which you put all the parameters at once.

Unit test: ctest -R test-parameters

---

function MakeException

TempLat::MakeException (
    ParameterParserMismatchSizes
) 

---

function MakeException

TempLat::MakeException (
    ParameterParserMismatchDefaultSizes
) 

---

function MakeException

TempLat::MakeException (
    ParameterParserDoesNotExist
) 

---

function MakeException

TempLat::MakeException (
    ParameterParserIsEmpty
) 

---

function MakeException

TempLat::MakeException (
    SessionGuardInstantiationException
) 

---

function MakeException

TempLat::MakeException (
    ConditionalFileStreamError
) 

---

function MakeException

TempLat::MakeException (
    FactorizationFailed
) 

---

function MakeException

TempLat::MakeException (
    KeccakHashBareClassReuseException
) 

---

function MakeException

TempLat::MakeException (
    RandomGaussianWrongCallOrderException
) 

---

function MakeException

TempLat::MakeException (
    EmptyModel
) 

---

function MakeException

TempLat::MakeException (
    NotTested
) 

---

function MakeException

TempLat::MakeException (
    PotentialDerivativeNotDefined
) 

---

function MakeException

TempLat::MakeException (
    NotEnoughChargesForThisCouplingsManager
) 

---

function MakeException

TempLat::MakeException (
    NotEnoughCouplingsForThisCouplingsManager
) 

---

function MakeException

A class that applies diffusion to the fields. Currently used to generate initial conditions of defect networks.

TempLat::MakeException (
    DiffusionEvolverInvalid
) 

---

function MakeException

TempLat::MakeException (
    MoreThanOneDoublet
) 

---

function MakeException

A class which interfaces the evolver, so we don't need to use pointers in the main.

TempLat::MakeException (
    EvolverTypeNotInEvolver
) 

---

function MakeException

TempLat::MakeException (
    InvalidEvolverTypeGW
) 

---

function MakeException

TempLat::MakeException (
    InvalidEvolverTypeAxion
) 

---

function MakeException

TempLat::MakeException (
    NotAnEvolverType
) 

---

function MakeException

TempLat::MakeException (
    NotPVEvolver
) 

---

function MakeException

TempLat::MakeException (
    NotVVEvolver
) 

---

function MakeException

TempLat::MakeException (
    ExtraMemoryNotAllocated
) 

---

function MakeException

TempLat::MakeException (
    PSTypeINotSupportedForNDIMDifferentFrom3
) 

---

function MakeException

A namespace that collects different types to specify different initial conditions,.

TempLat::MakeException (
    NotAnICType
) 

Unit test: make test-initialconditionstype

---

function MakeException

TempLat::MakeException (
    SICNotImplemented
) 

---

function MakeException

TempLat::MakeException (
    U1ICNotImplemented
) 

---

function MakeException

TempLat::MakeException (
    UseHDF5ButNotCompiled
) 

---

function MakeException

TempLat::MakeException (
    FileAlreadyExistsError
) 

---

function MakeException

TempLat::MakeException (
    WrongPSType
) 

---

function MakeException

TempLat::MakeException (
    WrongPRJType
) 

---

function MakeException

TempLat::MakeException (
    RunParametersMissing
) 

---

function MakeException

TempLat::MakeException (
    RunParametersInconsistent
) 

---

function NDLoop

A utility to perform N-dimensional loops over views. As this is not optimized for performance, it should only be used in tests. Naturally, NDLoop is a sequential loop - to use parallelism make use of device::iteration utilities. However, it is CPU-only and has therefore its special use cases.

template<size_t NDim, typename View, typename Functor>
void TempLat::NDLoop (
    const View & view,
    const Functor & functor
) 

Template parameters:

• NDim Dimensionality of the loop.
• View Type of the view being iterated over.
• Functor Type of the functor to be applied.

Parameters:

• v The view to iterate over.
• i The current index.

Returns:

requires

---

function PutToStream

Simple outputing of arrays and vectors: not exposing as operator<<, because below we want to limit it to vectors and arrays, without needing to know the exact number of template parameters for this systems implementation of array and vector.

template<typename T>
std::ostream & TempLat::PutToStream (
    std::ostream & stream,
    const T & vec
) 

---

function Real

A class which get real parts of fields.

template<class T>
auto TempLat::Real (
    T && t
) 

Unit test: ctest -R test-real

@vocab-summary Real part of a complex field or complex number.

---

function Real

template<class T>
auto TempLat::Real (
    T && t
) 

---

function Real

Real part of a getter whose eval() returns a complex value (e.g. RandomGaussianField in Fourier space). Bridges it into the complex-field protocol first, so Real(f) == Real(asComplexField(f)).

template<class T>
auto TempLat::Real (
    T && t
) 

---

function SU2DoubletWrap

template<class A, class B, class C, class D>
auto TempLat::SU2DoubletWrap (
    A && pA,
    B && pB,
    C && pC,
    D && pD
) 

@vocab-summary Builds a doublet expression from four component expressions, or from a lambda of the component tag. @vocab-signature SU2DoubletWrap(a, b, c, d) SU2DoubletWrap(f) @vocab-tags SU2Doublet

---

function SU2DoubletWrap

template<typename F>
auto TempLat::SU2DoubletWrap (
    F && f
) 

---

function SU2GroupWrap

template<class A, class B, class C>
auto TempLat::SU2GroupWrap (
    A && pA,
    B && pB,
    C && pC
) 

@vocab-summary Builds a genuine group element from three components, recovering \(c\_0\) from the unitarity constraint \(c\_0^2+c\_1^2+c\_2^2+c\_3^2=1\) so that \(\det U = 1\) holds by construction. @vocab-signature SU2GroupWrap(c1, c2, c3)

---

function SU2Wrap

template<class A, class B, class C, class D>
auto TempLat::SU2Wrap (
    const A & pA,
    const B & pB,
    const C & pC,
    const D & pD
) 

@vocab-summary Builds an SU(2)-valued expression from four component expressions, or from a lambda of the component tag. Nothing is stored: the result is a leaf in the expression tree. @vocab-signature SU2Wrap(c0, c1, c2, c3) SU2Wrap(f)

---

function SU2Wrap

template<typename F>
auto TempLat::SU2Wrap (
    const F & f
) 

---

function SayComplete

Instantiate a container that eats up all the stream that you put in it, only locking the mutex and throwing up into std::cerr upon destruction. Provide the filename and line number of the place of invocation. Use the macro 'say' defined below.

inline StreamCacher TempLat::SayComplete (
    const char * fname,
    int line
) 

Unit test: ctest -R test-saycomplete

---

function SetStacktracePtrToFileAddress

Posix's backtrace gives current memory addresses, which are good for runtime business, but not useful for finding source code locations. Need to convert that to file addresses, using this offset.

inline ptrdiff_t TempLat::SetStacktracePtrToFileAddress () 

---

function StacktracePlainptrs

Templated size: just throw in your array and we fill it to at most its size. Plain backtrace version.

template<size_t N>
inline void TempLat::StacktracePlainptrs (
    std::array< void *, N > * result,
    int * addrlen
) 

---

function StacktracePlainptrs

Templated size: just throw in your array and we fill it to at most its size. Libunwind (better!) version.

template<size_t N>
inline void TempLat::StacktracePlainptrs (
    std::array< void *, N > * result,
    int * addrlen
) 

---

function StacktracePtrToFileAddress

inline ptrdiff_t TempLat::StacktracePtrToFileAddress () 

---

function StripPathFromFileName

Performed by the compiler, if the const char* is a string at compile time.

constexpr const char * TempLat::StripPathFromFileName (
    const char * name
) noexcept

---

function Throws

A standalone function for testing of an exception is properly thrown. Returns a bool and a description.

template<typename Exception, typename Lambda>
std::pair< bool, std::string > TempLat::Throws (
    Lambda ll
) 

---

function TrailingZeroChar

Performed by the compiler, if the const char* is a string at compile time.

constexpr const char * TempLat::TrailingZeroChar (
    const char * name
) 

---

function abs

template<typename R>
auto TempLat::abs (
    const R & r
) 

---

function abs

Exposing our newly defined absolute value operation to the world.

template<typename T>
auto TempLat::abs (
    const T & a
) 

@vocab-summary Absolute value, element-wise.

---

function abs

inline constexpr ZeroType TempLat::abs (
    ZeroType a
) 

---

function abs

inline constexpr OneType TempLat::abs (
    OneType a
) 

---

function abs

inline constexpr HalfType TempLat::abs (
    HalfType a
) 

---

function acos

Exposing our newly defined acos operation to the world.

template<typename T>
auto TempLat::acos (
    T a
) 

@vocab-summary Arc cosine, element-wise.

---

function acos

Specialize for possible unit input! acos(1) = 0.

inline constexpr ZeroType TempLat::acos (
    OneType a
) 

---

function arg

template<class T>
auto TempLat::arg (
    T && t
) 

@vocab-summary Phase of a complex field, in \((-\pi, \pi]\).

---

function arg

template<class T>
auto TempLat::arg (
    T && t
) 

---

function arg

template<typename R, typename T>
auto TempLat::arg (
    R r,
    T t
) 

---

function arg2

A class which returns the phase of a complex field, between -pi and pi.

template<class T>
auto TempLat::arg2 (
    T && t
) 

Unit test: ctest -R test-arg

---

function arg2

template<class T>
auto TempLat::arg2 (
    T && t
) 

---

function arg2

template<typename R, typename T>
auto TempLat::arg2 (
    R r,
    T t
) 

@vocab-summary Two-argument arc tangent \(\mathrm{atan2}(y, x)\), giving a phase in \((-\pi, \pi]\). @vocab-signature arg2(y, x)

---

function asComplexField

template<typename R>
auto TempLat::asComplexField (
    R && r
) 

@vocab-summary Reinterprets an expression whose eval() already returns a complex value as a complex field, so the complex algebra applies to it.

---

function asFourier

template<typename R>
ComplexFieldAsFourier < R > TempLat::asFourier (
    R && r
) 

@vocab-summary Views a complex field as living in Fourier space, so that assignments and reductions on it are taken over momentum modes. @vocab-tags ComplexField, Fourier

---

function asinh

Exposing our newly define exp operation to the world.

template<typename T>
auto TempLat::asinh (
    T a
) 

@vocab-summary Inverse hyperbolic sine, element-wise.

---

function average

template<typename T>
auto TempLat::average (
    T instance,
    SpaceStateType spaceType=GetGetReturnType < T >::isComplex ? SpaceStateType::Fourier :SpaceStateType::Configuration
) 

---

function average

template<typename T>
auto TempLat::average (
    T expr
) 

@vocab-summary Average of an expression over the whole lattice and across all MPI ranks. Defaults to configuration or Fourier space according to the operand. @vocab-signature average(expr) average(expr, space)

---

function average

template<typename T>
auto TempLat::average (
    T a
) 

---

function average

auto TempLat::average (
    ZeroType a
) 

---

function backDiff

template<class R, int N>
auto TempLat::backDiff (
    R pR,
    Tag < N > t
) 

@vocab-summary Backward finite difference \(\big(f(x) - f(x-\hat e\_\mu)\big)/dx\) along direction mu. @vocab-signature backDiff(expr, mu)

---

function backDiff

template<class R, int N>
constexpr auto TempLat::backDiff (
    R,
    Tag < N >
) 

---

function backDiff

template<int NDim, typename R>
constexpr auto TempLat::backDiff (
    R
) 

---

function binary_fold

template<class BinaryOp, class Tuple, typename Function, typename Unity>
constexpr auto TempLat::binary_fold (
    BinaryOp && op,
    Tuple && tup,
    Function && func,
    Unity && unit
) 

---

function binary_fold_impl

template<class BinaryOp, class Tuple, typename Function, typename Unity>
constexpr auto TempLat::binary_fold_impl (
    BinaryOp && op,
    Tuple && tup,
    Function && func,
    Unity && unit,
    Tag <-1 > tg
) 

---

function binary_fold_impl

template<class BinaryOp, class Tuple, typename Function, typename Unity, int Index>
constexpr auto TempLat::binary_fold_impl (
    BinaryOp && op,
    Tuple && tup,
    Function && func,
    Unity && unit,
    Tag < Index > tg
) 

---

function binary_for_each

template<typename Tuple1, typename Tuple2, typename F>
constexpr void TempLat::binary_for_each (
    Tuple1 && tuple1,
    Tuple2 && tuple2,
    F && f
) 

---

function binary_for_each_impl

template<typename Tuple1, typename Tuple2, typename F, std::size_t... Indices>
constexpr void TempLat::binary_for_each_impl (
    Tuple1 && tuple1,
    Tuple2 && tuple2,
    F && f,
    std::index_sequence< Indices... >
) 

---

function commutator

template<typename R, typename T>
auto TempLat::commutator (
    const R & r,
    const T & t
) 

@vocab-summary Commutator \([A,B] = AB - BA\) of two SU(2)-valued expressions.

---

function commutator

template<typename T>
auto TempLat::commutator (
    OneType r,
    const T & t
) 

---

function commutator

template<typename R>
auto TempLat::commutator (
    const R & r,
    OneType t
) 

---

function commutator

template<typename T>
auto TempLat::commutator (
    ZeroType r,
    const T & t
) 

---

function commutator

template<typename R>
auto TempLat::commutator (
    const R & r,
    ZeroType t
) 

---

function complexPhase

template<typename R>
auto TempLat::complexPhase (
    R && r
) 

@vocab-summary Exponential map for \(U(1)\): turns a real phase \(\theta\) into the unit-modulus complex number \(e^{i\theta}\). @vocab-tags ComplexField

---

function complexfieldaverage

template<typename T>
auto TempLat::complexfieldaverage (
    T instance,
    SpaceStateType spaceType=IsComplexType< typename ComplexGetGetReturnType < T >::type > ? SpaceStateType::Fourier :SpaceStateType::Configuration
) 

@vocab-summary Lattice average of a complex expression, returning a complex result.

---

function conj

template<typename R>
auto TempLat::conj (
    const R & r
) 

---

function conj

template<typename R>
auto TempLat::conj (
    const R & r
) 

---

function conj

template<typename R>
auto TempLat::conj (
    const R & r
) 

---

function conj

Exposing our newly define multiplication operation to the world.

template<typename T>
auto TempLat::conj (
    const T & a
) 

@vocab-summary Complex conjugate, element-wise. Excluded for complex field types (HasComplexFieldGet) which have their own conj overload.

---

function conj

inline constexpr ZeroType TempLat::conj (
    ZeroType a
) 

---

function conj

inline constexpr OneType TempLat::conj (
    OneType a
) 

---

function conj

inline constexpr HalfType TempLat::conj (
    HalfType a
) 

---

function constexpr_for

A compile-time for loop, which calls the lambda f of signature void(integer) for each index.

template<auto Start, auto End, class F>
DEVICE_INLINE_FUNCTION constexpr void TempLat::constexpr_for (
    F && f
) 

---

function cos

Exposing our newly define exp operation to the world.

template<typename T>
auto TempLat::cos (
    T a
) 

@vocab-summary Cosine, element-wise.

---

function cos

Specialize for possible zero input!

inline constexpr OneType TempLat::cos (
    ZeroType a
) 

---

function cosh

Exposing our newly define exp operation to the world.

template<typename T>
auto TempLat::cosh (
    T a
) 

@vocab-summary Hyperbolic cosine, element-wise.

---

function cosh

Specialize for possible zero input!

inline constexpr OneType TempLat::cosh (
    ZeroType a
) 

---

function createParams

template<typename R>
auto TempLat::createParams (
    int argc,
    char * argv
) 

---

function dag

template<class R>
auto TempLat::dag (
    const R & r
) 

@vocab-summary Short spelling of dagger.

---

function dagger

template<typename R>
auto TempLat::dagger (
    const R & r
) 

---

function dagger

inline constexpr OneType TempLat::dagger (
    OneType
) 

---

function dagger

inline constexpr ZeroType TempLat::dagger (
    ZeroType
) 

---

function dagger

template<class R>
auto TempLat::dagger (
    const R & r
) 

@vocab-summary Hermitian conjugate. For SU(2) it negates the three vector components; the operator factory also simplifies as it builds, collapsing \((A^\dagger)^\dagger\) to \(A\) and commuting past a shift.

---

function dagger

template<class R>
auto TempLat::dagger (
    const SU2Dagger < R > & r
) 

---

function dagger

template<class A, class B>
auto TempLat::dagger (
    const SU2Multiplication < A, B > & m
) 

---

function dagger

template<class R, int... N>
auto TempLat::dagger (
    const SU2Shifter < R, N... > & s
) 

---

function dagger

template<class R, int N>
auto TempLat::dagger (
    const SU2ShifterByOne < R, N > & s
) 

---

function dagger

template<class R>
auto TempLat::dagger (
    const R & r
) 

---

function decay_tuple

template<typename T, std::size_t... Is>
auto TempLat::decay_tuple (
    T && t,
    std::index_sequence< Is... >
) 

---

function decay_tuple

template<typename T>
auto TempLat::decay_tuple (
    T && t
) 

---

function derivatives

template<typename T, typename R>
auto TempLat::derivatives (
    T && expr,
    R & others
) 

@vocab-summary Symbolic derivative of an expression with respect to each field in a collection, returned as a tuple. Provided for completeness; nothing in TempLat uses it.

---

function dot

template<typename R, typename T>
VectorDotter < R, T > TempLat::dot (
    R r,
    T t
) 

@vocab-summary Dot product of two vector expressions, \(\sum\_i a\_i b\_i\).

---

function electricField2

template<typename R>
auto TempLat::electricField2 (
    R Es,
    Tag < 1 > t
) 

@vocab-summary Site-centred electric field: the average of the two links straddling a site in each direction. Returns a vector expression when called without an index. @vocab-signature electricField2(Es) electricField2(Es, i)

---

function electricField2

template<typename R>
auto TempLat::electricField2 (
    R Es,
    Tag < 2 > t
) 

---

function electricField2

template<typename R>
auto TempLat::electricField2 (
    R Es,
    Tag < 3 > t
) 

---

function electricField2

template<typename R>
auto TempLat::electricField2 (
    R && Es
) 

---

function exp

template<typename R>
auto TempLat::exp (
    const R & r
) 

---

function exp

Exposing our newly define exp operation to the world.

template<typename T>
auto TempLat::exp (
    T a
) 

@vocab-summary Exponential \(e^x\), element-wise. @vocab-primary

---

function exp

Specialize for possible zero input!

inline constexpr OneType TempLat::exp (
    ZeroType a
) 

---

function exp

template<class R>
auto TempLat::exp (
    const R & r
) 

@vocab-summary Exponential map from the su(2) algebra to the SU(2) group.

---

function expinv

template<class R>
auto TempLat::expinv (
    const R & r
) 

@vocab-summary Inverse of the SU(2) exponential map — the logarithm, taking a group element back to the algebra.

---

function explode

A class which flatten all directions of a composite object.

template<typename T>
auto TempLat::explode (
    T && t,
    char
) 

Unit test: ctest -R test-flattentuple

---

function explode

template<typename T, std::size_t I>
auto TempLat::explode (
    T && t,
    int
) 

---

function explode

template<typename T, std::size_t... Is>
auto TempLat::explode (
    T && t,
    std::index_sequence< Is... >
) 

---

function fieldStrength

Returns the field strength tensor F_{mu,nu} = d_mu A_nu - d_nu A_mu, where A is a gauge field and d is a forward derivative, using a forward finite difference.

template<typename R, int Mu, int Nu>
auto TempLat::fieldStrength (
    R A,
    Tag < Mu > mu,
    Tag < Nu > nu
) 

Parameters:

• A The gauge field
• mu The first index of the field strength tensor.
• nu The second index of the field strength tensor.

@vocab-summary Abelian field strength \(F\_{\mu\nu} = \partial\_\mu A\_\nu - \partial\_\nu A\_\mu\) from forward differences of the gauge potential. @vocab-signature fieldStrength(As, mu, nu)

---

function fieldStrengthCtr

Returns the field strength tensor F_{mu,nu} = d_mu A_nu - d_nu A_mu, where A is a gauge field and d is a forward derivative, using a central finite difference.

template<typename R, int Mu, int Nu>
auto TempLat::fieldStrengthCtr (
    R A,
    Tag < Mu > mu,
    Tag < Nu > nu
) 

Parameters:

• A The gauge field
• mu The first index of the field strength tensor.
• nu The second index of the field strength tensor.

@vocab-summary Field strength built from centred rather than forward differences. @vocab-signature fieldStrengthCtr(As, mu, nu)

---

function flatten

A function which flattens a std::vector.

template<typename NestedVec>
std::vector< typename std_atomic_type < NestedVec >::type > TempLat::flatten (
    const NestedVec & nested
) 

Unit test: ctest -R test-flattenstd

---

function flatten_helper

template<typename T>
std::enable_if<! is_std_vector < T >::value >::type TempLat::flatten_helper (
    const T & elem,
    std::vector< T > & flat
) 

---

function flatten_helper

template<typename T>
std::enable_if< is_std_vector < T >::value >::type TempLat::flatten_helper (
    const T & nested,
    std::vector< typename std_atomic_type < T >::type > & flat
) 

---

function flatten_tuple

template<typename T, std::size_t... Is>
auto TempLat::flatten_tuple (
    T && t,
    std::index_sequence< Is... >
) 

---

function flatten_tuple

template<typename T>
auto TempLat::flatten_tuple (
    T && t
) 

---

function fold_multiply

Multiplies all the components of a tuple after applying func to them.

template<class Tuple, typename Function>
constexpr auto TempLat::fold_multiply (
    Tuple && tup,
    Function && func
) 

Unit test: ctest -R test-foldmultiply

Parameters:

• tup the tuple to multiply over
• func the function to apply to each component before multiplying

---

function fold_multiply

Multiplies all the components of a tuple.

template<class Tuple>
constexpr auto TempLat::fold_multiply (
    Tuple && tup
) 

Unit test: ctest -R test-foldmultiply

Parameters:

• tup the tuple to multiply over

---

function fold_multiply_impl

template<class Tuple, typename Function, typename Unit, int... INT>
constexpr auto TempLat::fold_multiply_impl (
    Tuple && tup,
    Function && func,
    Unit && unit,
    std::integer_sequence< int, INT... > iseq
) 

---

function fold_multiply_unit

Multiplies all the components of a tuple after applying func to them, starting from unit.

template<class Tuple, class Unit>
constexpr auto TempLat::fold_multiply_unit (
    Tuple && tup,
    Unit && unit
) 

Unit test: ctest -R test-foldmultiply

Parameters:

• tup the tuple to multiply over
• func the function to apply to each component before multiplying
• unit the unit to start multiplying from

---

function for_each

template<typename Tuple, typename F>
constexpr void TempLat::for_each (
    Tuple && tuple,
    F && f
) 

---

function for_each_impl

A class which.

template<typename Tuple, typename F, std::size_t... Indices>
constexpr void TempLat::for_each_impl (
    Tuple && tuple,
    F && f,
    std::index_sequence< Indices... >
) 

A tuple friendly for_each. From https://codereview.stackexchange.com/a/163802

---

function for_in_range

A function which implements a static for loop. Note that this for-loop is INCLUSIVE of the start AND end.

template<int i, int j, typename F>
void TempLat::for_in_range (
    F && f
) 

Unit test: ctest -R test-for_in_range

---

function forwDiff

template<class R, int N>
auto TempLat::forwDiff (
    R pR,
    Tag < N > t
) 

@vocab-summary Forward finite difference \(\big(f(x+\hat e\_\mu) - f(x)\big)/dx\) along direction mu. @vocab-signature forwDiff(expr, mu)

---

function forwDiff

template<class R, int N>
constexpr auto TempLat::forwDiff (
    R,
    Tag < N >
) 

---

function forwDiff

template<int NDim, typename R>
constexpr auto TempLat::forwDiff (
    R
) 

---

function forwDij

template<class R, int N>
auto TempLat::forwDij (
    R pR,
    Tag < N > t
) 

@vocab-summary Forward two-point sum \(\big(f(x) + f(x+\hat e\_\mu)\big)/dx\) — the averaging counterpart of forwDiff, used where a gauge-covariant discretisation needs the sum rather than the difference. @vocab-signature forwDij<dir>(expr)

---

function forwDij

template<int NDim, typename R>
constexpr auto TempLat::forwDij (
    R
) 

---

function getAverager

template<typename T>
auto TempLat::getAverager (
    T instance,
    SpaceStateType spaceType=GetGetReturnType < T >::isComplex ? SpaceStateType::Fourier :SpaceStateType::Configuration
) 

---

function getFFTWSessionGuard

inline std::shared_ptr< FFTSessionGuard > TempLat::getFFTWSessionGuard (
    bool pVerbose=true
) 

---

function getTypeIBinCounts

template<size_t NDim>
std::vector< int > TempLat::getTypeIBinCounts (
    const device::Idx N
) 

---

function getVectorComponent

template<int N, typename R>
GetVectorComponentHelper < N, R > TempLat::getVectorComponent (
    const R & pR,
    Tag < N >
) 

---

function heaviside

template<typename R>
auto TempLat::heaviside (
    const R & r
) 

@vocab-summary Heaviside step function, with the convention \(H(0)=1\). Its symbolic derivative is DiracDelta.

---

function heaviside

Specialize for possible zero input!

inline constexpr OneType TempLat::heaviside (
    ZeroType a
) 

---

function heaviside

Specialize for possible unit input!

inline constexpr OneType TempLat::heaviside (
    OneType a
) 

---

function integrate

template<typename T>
T TempLat::integrate (
    const std::vector< T > & vec,
    T dt
) 

---

function log

template<typename R>
auto TempLat::log (
    const R & r
) 

---

function log

Exposing our newly define log operation to the world.

template<typename T>
auto TempLat::log (
    T a
) 

@vocab-summary Natural logarithm, element-wise.

---

function log

Specialize for possible zero output!

inline constexpr ZeroType TempLat::log (
    OneType a
) 

---

function magneticField

A function to return the magnetic field from the gauge potential. Specialised to 3D. TODO: ND?

template<typename R>
auto TempLat::magneticField (
    R && As,
    Tag < 1 > t
) 

@vocab-summary Magnetic field from the gauge potential, \(B\_i = \tfrac12\epsilon\_{ijk}F\_{jk}\). Specialised to three dimensions.

---

function magneticField

template<typename R>
auto TempLat::magneticField (
    R && As,
    Tag < 2 > t
) 

---

function magneticField

template<typename R>
auto TempLat::magneticField (
    R && As,
    Tag < 3 > t
) 

---

function magneticField

template<typename R>
auto TempLat::magneticField (
    R && As
) 

---

function magneticField4

A function to get the average between the 4 links of the magnetic field from the gauge potential. Specialised to 3D.

template<typename R>
auto TempLat::magneticField4 (
    R Bs,
    Tag < 1 > t
) 

Unit test: make test-magneticfield

@vocab-summary Site-centred magnetic field: the average over the four plaquettes around a site in each direction. Specialised to three dimensions. @vocab-signature magneticField4(Bs) magneticField4(Bs, i)

---

function magneticField4

template<typename R>
auto TempLat::magneticField4 (
    R && Bs,
    Tag < 2 > t
) 

---

function magneticField4

template<typename R>
auto TempLat::magneticField4 (
    R && Bs,
    Tag < 3 > t
) 

---

function magneticField4

template<typename R>
auto TempLat::magneticField4 (
    R && Bs
) 

---

function magneticFieldCtr

A function to return the magnetic field from the gauge potential using centered finite derivatives. Specialised to 3D. TODO: ND?

template<typename R>
auto TempLat::magneticFieldCtr (
    R && As,
    Tag < 1 > t
) 

@vocab-summary Magnetic field from centred differences of the gauge potential.

---

function magneticFieldCtr

template<typename R>
auto TempLat::magneticFieldCtr (
    R && As,
    Tag < 2 > t
) 

---

function magneticFieldCtr

template<typename R>
auto TempLat::magneticFieldCtr (
    R && As,
    Tag < 3 > t
) 

---

function magneticFieldCtr

template<typename R>
auto TempLat::magneticFieldCtr (
    R && As
) 

---

function makeUniformArray

template<typename T, size_t N>
inline device::array< T, N > TempLat::makeUniformArray (
    const T & value
) 

---

function make_flat_list

A class which creates a flat tuple from potentially a list of composite objects.

template<typename... Args>
auto TempLat::make_flat_list (
    Args... args
) 

Unit test: ctest -R test-makeflatlist

---

function make_latinindices_list

template<class... Args>
auto TempLat::make_latinindices_list (
    Args... args
) 

---

function make_list

template<class... Args>
auto TempLat::make_list (
    Args... args
) 

---

function make_list_from_array

template<typename T, size_t N>
auto TempLat::make_list_from_array (
    std::array< T, N > arr
) 

---

function make_list_from_array

template<typename T>
int TempLat::make_list_from_array (
    std::array< T, 0 > arr
) 

---

function make_list_tag

template<int Start, int End, typename F>
inline constexpr auto TempLat::make_list_tag (
    F && f
) 

---

function make_list_tag

template<int End, typename F>
inline constexpr auto TempLat::make_list_tag (
    F && f
) 

---

function make_list_tag_impl

A class which.

template<int Start, typename F, int... I>
inline auto TempLat::make_list_tag_impl (
    F && f,
    std::integer_sequence< int, I... > iseq
) 

Unit test: ctest -R test-make_list_tag

---

function make_templatvector

template<typename... Args>
auto TempLat::make_templatvector (
    Args... args
) 

---

function make_tuple_from

template<typename R>
auto TempLat::make_tuple_from (
    R && r
) 

---

function make_tuple_from

template<typename R>
auto TempLat::make_tuple_from (
    R && r
) 

---

function make_tuple_sequence

template<std::size_t I, typename T>
constexpr auto TempLat::make_tuple_sequence () 

---

function make_tuple_sequence_helper

template<typename T, T... I>
constexpr auto TempLat::make_tuple_sequence_helper (
    std::integer_sequence< T, I... >
) 

---

function make_tuple_tag

template<int Start, int End, typename F>
auto TempLat::make_tuple_tag (
    F && f
) 

---

function make_tuple_tag

template<int End, typename F>
auto TempLat::make_tuple_tag (
    F && f
) 

---

function make_tuple_tag_impl

Function that creates a tuple of (f(Tag<0>, ..., f(Tag<N>) ).

template<int Start, typename F, int... I>
auto TempLat::make_tuple_tag_impl (
    F && f,
    std::integer_sequence< int, I... > iseq
) 

Unit test: ctest -R test-make_tuple_tag

---

function make_vector

template<class... Args>
auto TempLat::make_vector (
    Args... args
) 

---

function make_vector_tag

template<int Start, int End, typename F>
inline constexpr auto TempLat::make_vector_tag (
    F && f
) 

---

function make_vector_tag

template<int End, typename F>
inline constexpr auto TempLat::make_vector_tag (
    F && f
) 

---

function make_vector_tag_impl

template<int Start, typename F, int... I>
inline auto TempLat::make_vector_tag_impl (
    F && f,
    std::integer_sequence< int, I... > iseq
) 

---

function max

template<typename T>
auto TempLat::max (
    T instance,
    SpaceStateType spaceType=GetGetReturnType < T >::isComplex ? SpaceStateType::Fourier :SpaceStateType::Configuration
) 

@vocab-summary Largest value an expression takes anywhere on the lattice, reduced across all ranks.

---

function max

auto TempLat::max (
    ZeroType a
) 

---

function multiplyTrace

template<typename R, typename T>
auto TempLat::multiplyTrace (
    const R & r,
    const T & t
) 

@vocab-summary Trace of the product of two \(3\times3\) matrix expressions, \(\mathrm{tr}(AB)\), evaluated without ever forming the product. @vocab-signature multiplyTrace(a, b)

---

function multiplyTrace

template<typename R, typename T>
auto TempLat::multiplyTrace (
    const R & r,
    const T & t
) 

---

function multiplyTrace

template<typename R, typename T>
auto TempLat::multiplyTrace (
    const R & r,
    const T & t
) 

---

function neutDiff

template<class R, int N>
auto TempLat::neutDiff (
    R pR,
    Tag < N > t
) 

@vocab-summary Centred finite difference \(\big(f(x+\hat e\_\mu) - f(x-\hat e\_\mu)\big)/2dx\), accurate to \(O(dx^2)\). @vocab-signature neutDiff(expr, mu)

---

function neutDiff

template<int NDim, typename R>
constexpr auto TempLat::neutDiff (
    R
) 

---

function neutDij

template<class R, int N>
auto TempLat::neutDij (
    R pR,
    Tag < N > t
) 

@vocab-summary Centred two-point sum \(\big(f(x+\hat e\_\mu) + f(x-\hat e\_\mu)\big)/2dx\), the averaging counterpart of neutDiff. @vocab-signature neutDij<dir>(expr)

---

function neutDij

template<int NDim, typename R>
constexpr auto TempLat::neutDij (
    R pR
) 

---

function nonabelianclover

A function that returns the clover discretization of non-abelian magnetic fields.

template<int Mu, int Nu, typename R>
auto TempLat::nonabelianclover (
    const R & Us,
    Tag < Mu > mu,
    Tag < Nu > nu
) 

Parameters:

• Us The gauge links.
• mu The first direction of the clover. Should be a spatial direction.
• nu The second direction of the clover. Should be a spatial direction.

@vocab-summary Clover discretisation of the non-abelian field strength: the average of the four plaquettes touching a site in the \((\mu,\nu)\) plane, which restores the symmetry a single plaquette breaks. @vocab-signature nonabelianclover(Us, mu, nu)

---

function norm

template<typename R>
auto TempLat::norm (
    R r
) 

@vocab-summary Euclidean norm of a vector expression, sqrt(norm2(v)).

---

function norm2

template<typename R>
auto TempLat::norm2 (
    R && r
) 

---

function norm2

A class which computes the norm of a list.

template<typename R>
auto TempLat::norm2 (
    const R & r
) 

Unit test: ctest -R test-norm

@vocab-summary Squared norm: the sum of the squares of the components. Defined for collections, complex fields and doublets.

---

function norm2

template<typename R>
auto TempLat::norm2 (
    R r
) 

---

function norm2

template<typename R>
auto TempLat::norm2 (
    const R & r
) 

---

function operator!=

template<int M, int N>
constexpr bool TempLat::operator!= (
    Tag < M > t1,
    Tag < N > t2
) 

---

function operator""_c

template<char... c>
constexpr auto TempLat::operator""_c () 

---

function operator*

template<typename R, typename T>
auto TempLat::operator* (
    const R & r,
    const T & t
) 

---

function operator*

template<typename R, typename T>
auto TempLat::operator* (
    const R & r,
    const T & t
) 

---

function operator*

template<typename R, typename T>
auto TempLat::operator* (
    const R & r,
    const T & t
) 

---

function operator*

template<typename R, typename T>
auto TempLat::operator* (
    const R & r,
    const T & t
) 

---

function operator*

template<typename R, typename T>
auto TempLat::operator* (
    const R & r,
    const T & t
) 

---

function operator*

template<typename R, typename T>
auto TempLat::operator* (
    const R & r,
    const T & t
) 

---

function operator*

template<typename R, typename T>
auto TempLat::operator* (
    const R & r,
    const T & t
) 

---

function operator*

template<typename R, typename T>
auto TempLat::operator* (
    const R & r,
    const T & t
) 

---

function operator*

template<typename R, typename T>
auto TempLat::operator* (
    const R & r,
    const T & t
) 

---

function operator*

template<typename R, typename T>
auto TempLat::operator* (
    const R & r,
    const T & t
) 

---

function operator*

template<typename R, typename T>
auto TempLat::operator* (
    const R & r,
    const T & t
) 

---

function operator*

Exposing our newly define multiplication operation to the world.

template<typename R, typename T>
auto TempLat::operator* (
    const R & r,
    const T & t
) 

@vocab-summary Product of two expressions. The meaning follows the operands: numbers and fields multiply point-wise, SU(2) elements compose as quaternions, matrices contract, collections multiply component-wise.

---

function operator*

template<typename R, int N>
auto TempLat::operator* (
    const R & r,
    Tag < N > n
) 

---

function operator*

template<typename R, int N>
auto TempLat::operator* (
    Tag < N > n,
    const R & r
) 

---

function operator*

template<int M, int N>
constexpr auto TempLat::operator* (
    Tag < N > n,
    Tag < M > m
) 

---

function operator*

Specialize for ZeroType *ZeroType .

inline constexpr ZeroType TempLat::operator* (
    ZeroType,
    ZeroType
) 

---

function operator*

Specialize for possible zero input!

template<typename T>
ZeroType TempLat::operator* (
    const T &,
    ZeroType b
) 

---

function operator*

Specialize for possible zero input!

template<typename T>
constexpr ZeroType TempLat::operator* (
    ZeroType a,
    const T &
) 

---

function operator*

Specialize for possible unit input!

template<typename T>
constexpr auto TempLat::operator* (
    const T & a,
    const OneType b
) 

---

function operator*

Specialize for possible unit input!

template<typename T>
constexpr auto TempLat::operator* (
    const OneType & a,
    const T & b
) 

---

function operator*

Specialize for possible unit input!

inline constexpr OneType TempLat::operator* (
    OneType a,
    OneType b
) 

---

function operator*

template<typename R, typename T>
auto TempLat::operator* (
    const R & r,
    const T & t
) 

---

function operator*

template<typename R, typename T>
auto TempLat::operator* (
    const R & r,
    const T & t
) 

---

function operator*

template<typename R, typename T>
auto TempLat::operator* (
    const R & r,
    const T & t
) 

---

function operator*

template<typename R, typename T>
auto TempLat::operator* (
    const T & t,
    const R & r
) 

---

function operator*

template<typename R, typename T>
auto TempLat::operator* (
    const R & r,
    const T & t
) 

---

function operator*

template<typename R, typename T>
auto TempLat::operator* (
    R r,
    const T & t
) 

---

function operator*

template<typename R, typename T>
auto TempLat::operator* (
    const R & r,
    const T & t
) 

---

function operator*

template<typename R, typename T>
auto TempLat::operator* (
    const R & r,
    const T & t
) 

---

function operator*

template<typename T, class R>
RadialProjectionResult < T > TempLat::operator* (
    R && func,
    const RadialProjectionResult < T > & obj
) 

---

function operator*

template<typename T>
RadialProjectionResult < T > TempLat::operator* (
    double scale,
    const RadialProjectionResult < T > & obj
) 

---

function operator*

template<typename T>
RadialProjectionResult < T > TempLat::operator* (
    float scale,
    const RadialProjectionResult < T > & obj
) 

---

function operator*

template<typename T>
RadialProjectionResult < T > TempLat::operator* (
    int scale,
    const RadialProjectionResult < T > & obj
) 

---

function operator*

template<typename T, class R>
UnbinnedRadialProjectionResult < T > TempLat::operator* (
    R && func,
    const UnbinnedRadialProjectionResult < T > & obj
) 

---

function operator*

template<typename T>
UnbinnedRadialProjectionResult < T > TempLat::operator* (
    double scale,
    const UnbinnedRadialProjectionResult < T > & obj
) 

---

function operator*

template<typename T>
UnbinnedRadialProjectionResult < T > TempLat::operator* (
    float scale,
    const UnbinnedRadialProjectionResult < T > & obj
) 

---

function operator*

template<typename T>
UnbinnedRadialProjectionResult < T > TempLat::operator* (
    int scale,
    const UnbinnedRadialProjectionResult < T > & obj
) 

---

function operator*

template<int M, int N>
Tag < M *N > TempLat::operator* (
    Tag < M > t1,
    Tag < N > t2
) 

---

function operator+

template<typename R, typename T>
auto TempLat::operator+ (
    const R & r,
    const T & t
) 

---

function operator+

template<typename R, typename T>
auto TempLat::operator+ (
    const R & r,
    const T & t
) 

---

function operator+

template<typename R, typename T>
auto TempLat::operator+ (
    const R & r,
    const T & t
) 

---

function operator+

template<typename R, typename T>
auto TempLat::operator+ (
    const R & r,
    const T & t
) 

---

function operator+

template<typename R, typename T>
auto TempLat::operator+ (
    const R & r,
    const T & t
) 

---

function operator+

template<typename R, typename T>
auto TempLat::operator+ (
    const R & r,
    const T & t
) 

@vocab-summary Element-wise sum. Every algebra defines its own, so the operands may be numbers, scalar or complex fields, SU(2) elements, doublets, 3x3 matrices or collections.

---

function operator+

Specialize for possible zero input!

inline constexpr auto TempLat::operator+ (
    const ZeroType a,
    const ZeroType b
) 

---

function operator+

Specialize for possible half input!

inline constexpr OneType TempLat::operator+ (
    const HalfType a,
    const HalfType b
) 

---

function operator+

Specialize for possible zero input! Need to disable one of these for two ZeroTypes as input.

template<typename T>
T TempLat::operator+ (
    const ZeroType a,
    const T b
) 

---

function operator+

Specialize for possible zero input! Need to disable one of these for two ZeroTypes as input.

template<typename T>
T TempLat::operator+ (
    const T b,
    const ZeroType a
) 

---

function operator+

template<typename R, typename T>
auto TempLat::operator+ (
    const R & r,
    const T & t
) 

---

function operator+

template<typename R, typename T>
auto TempLat::operator+ (
    const R & r,
    const T & t
) 

---

function operator+

template<typename T>
RadialProjectionResult < T > TempLat::operator+ (
    const RadialProjectionResult < T > & a,
    const RadialProjectionResult < T > & b
) 

---

function operator+

template<typename T>
UnbinnedRadialProjectionResult < T > TempLat::operator+ (
    const UnbinnedRadialProjectionResult < T > & a,
    const UnbinnedRadialProjectionResult < T > & b
) 

---

function operator+

template<int M, int N>
Tag < M+N > TempLat::operator+ (
    Tag < M > t1,
    Tag < N > t2
) 

---

function operator-

template<typename R, typename T>
auto TempLat::operator- (
    const R & r,
    const T & t
) 

---

function operator-

template<typename R, typename T>
auto TempLat::operator- (
    const R & r,
    const T & t
) 

---

function operator-

template<typename R, typename T>
auto TempLat::operator- (
    const R & r,
    const T & t
) 

---

function operator-

template<typename R, typename T>
auto TempLat::operator- (
    const R & r,
    const T & t
) 

---

function operator-

template<typename R>
auto TempLat::operator- (
    const R & r
) 

---

function operator-

template<typename R, typename T>
auto TempLat::operator- (
    const R & r,
    const T & t
) 

---

function operator-

template<typename R, typename T>
Operators::Subtraction < R, T > TempLat::operator- (
    const R & r,
    const T & t
) 

@vocab-summary Element-wise difference; the unary form negates. Defined for every algebra.

---

function operator-

Specialize for possible zero input!

template<typename T>
T & TempLat::operator- (
    T && a,
    ZeroType b
) 

---

function operator-

Specialize for possible zero input! Need to disable one of these for two ZeroTypes as input.

template<typename T>
auto TempLat::operator- (
    ZeroType a,
    const T & b
) 

---

function operator-

Specialize for unary minus.

template<typename T, typename S>
auto TempLat::operator- (
    T && a,
    Operators::UnaryMinus < S > && b
) 

---

function operator-

Specialize for possible half input!

inline constexpr HalfType TempLat::operator- (
    const OneType a,
    const HalfType b
) 

---

function operator-

Specialize for possible half input!

inline auto TempLat::operator- (
    HalfType a,
    OneType b
) 

---

function operator-

Specialize for possible OneType __OneType input.

inline constexpr auto TempLat::operator- (
    OneType a,
    OneType b
) 

---

function operator-

Exposing our newly defined subtraction operation to the world.

template<typename T>
auto TempLat::operator- (
    const T & a
) 

---

function operator-

Specialize for possible zero input!

inline constexpr ZeroType TempLat::operator- (
    ZeroType a
) 

---

function operator-

Specialize for double minus signs: -(-(-x)) collapses to -x. The argument a == -(-x) == +x, so -a == -x, which is exactly the inner UnaryMinus<T> node a.mR.

template<typename T>
auto TempLat::operator- (
    Operators::UnaryMinus < Operators::UnaryMinus < T > > && a
) 

---

function operator-

template<typename R, typename T>
auto TempLat::operator- (
    const R & r,
    const T & t
) 

---

function operator-

template<typename R, typename T>
auto TempLat::operator- (
    const R & r,
    const T & t
) 

---

function operator-

template<int M, int N>
Tag < M - N > TempLat::operator- (
    Tag < M > t1,
    Tag < N > t2
) 

---

function operator-

template<int M>
Tag <-M > TempLat::operator- (
    Tag < M > t1
) 

---

function operator/

template<typename R, typename T>
auto TempLat::operator/ (
    const R & r,
    const T & t
) 

---

function operator/

template<typename R, typename T>
auto TempLat::operator/ (
    const R & r,
    const T & t
) 

---

function operator/

template<typename R, typename T>
auto TempLat::operator/ (
    const R & r,
    const T & t
) 

---

function operator/

Exposing our newly define multiplication operation to the world.

template<typename R, typename T>
auto TempLat::operator/ (
    const R & r,
    const T & t
) 

@vocab-summary Element-wise division.

---

function operator/

Specialize for possible unit input! Simplify derivatives for example.

template<typename T>
constexpr T TempLat::operator/ (
    const T & a,
    OneType b
) 

---

function operator/

Specialize for possible zero input! Need to disable one of these for two ZeroTypes as input.

template<typename T>
constexpr auto TempLat::operator/ (
    const ZeroType & a,
    const T &
) 

---

function operator/

template<typename R, typename T>
auto TempLat::operator/ (
    const T & t,
    const R & r
) 

---

function operator<

template<int M, int N>
constexpr bool TempLat::operator< (
    Tag < M > t1,
    Tag < N > t2
) 

---

function operator<

template<int M, int N>
constexpr bool TempLat::operator< (
    Tag < M > t1,
    Tag < N > t2
) 

---

function operator<<

Enable simple operator<< for all objects with a toString method.

template<typename T>
std::ostream & TempLat::operator<< (
    std::ostream & ostream,
    const T & obj
) 

---

function operator<<

template<size_t NDim>
inline std::ostream & TempLat::operator<< (
    std::ostream & ostream,
    SpaceStateType st
) 

---

function operator<<

inline std::ostream & TempLat::operator<< (
    std::ostream & ostream,
    const HermitianRedundancy & hr
) 

---

function operator<<

template<typename T, size_t N>
std::ostream & TempLat::operator<< (
    std::ostream & stream,
    const device::array< T, N > & vec
) 

---

function operator<<

template<typename T, typename K>
std::ostream & TempLat::operator<< (
    std::ostream & stream,
    const std::pair< T, K > & p
) 

---

function operator<<

template<typename C>
std::ostream & TempLat::operator<< (
    std::ostream & stream,
    const C & vec
) 

---

function operator<<

template<int N>
std::ostream & TempLat::operator<< (
    std::ostream & os,
    const Tag < N > & t
) 

---

function operator<=

template<int M, int N>
constexpr bool TempLat::operator<= (
    Tag < M > t1,
    Tag < N > t2
) 

---

function operator<=

template<int M, int N>
constexpr bool TempLat::operator<= (
    Tag < M > t1,
    Tag < N > t2
) 

---

function operator==

template<int M, int N>
constexpr bool TempLat::operator== (
    Tag < M > t1,
    Tag < N > t2
) 

---

function operator>

template<int M, int N>
constexpr bool TempLat::operator> (
    Tag < M > t1,
    Tag < N > t2
) 

---

function operator>

template<int M, int N>
constexpr bool TempLat::operator> (
    Tag < M > t1,
    Tag < N > t2
) 

---

function operator>=

template<int M, int N>
constexpr bool TempLat::operator>= (
    Tag < M > t1,
    Tag < N > t2
) 

---

function operator>=

template<int M, int N>
constexpr bool TempLat::operator>= (
    Tag < M > t1,
    Tag < N > t2
) 

---

function operator>>

std::istream & TempLat::operator>> (
    std::istream & in,
    EvolverType & eType
) 

---

function parse

template<std::size_t N>
constexpr long long TempLat::parse (
    const char(&) arr
) 

---

function plaq

A class which defines plaquette operator.

template<int Mu, int Nu, typename R>
auto TempLat::plaq (
    R Us,
    Tag < Mu > mu,
    Tag < Nu > nu
) 

Unit test: ctest -R test-plaquette

@vocab-summary Plaquette \(P\_{\mu\nu}(x) = U\_\mu(x)\,U\_\nu(x+\hat\mu)\,U^\dagger\_\mu(x+\hat\nu)\,U^\dagger\_\nu(x)\). The product is deliberately bracketed in pairs: fully expanding a chain of six or more link matrices overflows the stack. @vocab-signature plaq(Us, mu, nu)

---

function plaqBack

A class which implemets a backward plaquette. Useful in equations of motions for example.

template<int Mu, int Nu, typename R>
auto TempLat::plaqBack (
    const R & Us,
    Tag < Mu > mu,
    Tag < Nu > nu
) 

Unit test: ctest -R test-plaquetteback

@vocab-summary The plaquette traversed backwards in \(\nu\), needed alongside plaq when assembling equations of motion. @vocab-signature plaqBack(Us, mu, nu)

---

function pow

template<typename R, typename T>
auto TempLat::pow (
    const R & r,
    const T & t
) 

---

function pow

template<int N, typename R>
auto TempLat::pow (
    const R & r
) 

---

function pow

template<typename R, typename T>
auto TempLat::pow (
    const R & r,
    const T & t
) 

@vocab-summary Raises an expression to a power. \(x^N\) with a compile-time exponent unrolls into repeated multiplication; the two-argument form is general. \(N=0\) folds to OneType and \(N=1\) to the operand itself, at compile time. @vocab-signature pow<N>(x) pow(x, y)

---

function pow

template<int N>
constexpr ZeroType TempLat::pow (
    ZeroType
) 

---

function pow

template<typename T>
constexpr OneType TempLat::pow (
    const T & a,
    ZeroType b
) 

---

function pow

Specialize for possible zero input! Need to disable one of these for two ZeroTypes as input.

template<typename T>
constexpr auto TempLat::pow (
    ZeroType a,
    const T &
) 

---

function pow

template<int N, typename R>
auto TempLat::pow (
    const R & r
) 

---

function pow

template<int N, typename R>
auto TempLat::pow (
    const R & r
) 

---

function pow

Specialize for possible zero input!

template<int N, typename T>
constexpr auto TempLat::pow (
    const T & a
) 

---

function pow

Specialize for possible one input!

template<int N, typename T>
T TempLat::pow (
    const T & a
) 

---

function powr

A compile-time evaluatable power function for whole number exponents. This implementation generates some rather efficient instructions, see ( https://godbolt.org/z/vT56bb1nx ).

template<int n, typename NumberType>
constexpr DEVICE_INLINE_FUNCTION NumberType TempLat::powr (
    const NumberType x
) 

Template parameters:

• n Exponent of type int
• RF Type of argument

Parameters:

• x Argument

Returns:

x^n

---

function projectChiralU1Type1

template<typename Model, int U1, int C>
auto TempLat::projectChiralU1Type1 (
    const Model & model,
    Tag < U1 >,
    Tag < C >,
    bool sign,
    bool AorE
) 

---

function projectGWType1

template<typename Model>
auto TempLat::projectGWType1 (
    const Model & model
) 

---

function projectGWType2

template<typename Model>
auto TempLat::projectGWType2 (
    const Model & model
) 

---

function projectGWType3

template<typename Model>
auto TempLat::projectGWType3 (
    const Model & model
) 

---

function projectRadially

template<size_t NDim, typename T>
RadialProjector < T > TempLat::projectRadially (
    T instance,
    SpaceStateType spaceType,
    device::memory::host_ptr < MemoryToolBox < NDim > > pToolBox,
    bool useBinCentralValues=false
) 

@vocab-summary Bins an expression by radius, giving a radial profile of an \(N\)-dimensional lattice.

---

function projectRadially

template<typename T>
RadialProjector < T > TempLat::projectRadially (
    T instance,
    bool useBinCentralValues=false
) 

---

function projectRadiallyFourier

template<typename T>
RadialProjector < T > TempLat::projectRadiallyFourier (
    T instance,
    bool useBinCentralValues=false
) 

@vocab-summary Bins an expression by \(\|k\|\), the usual way to take a power spectrum. @vocab-tags Field, Fourier

---

function reverse_array

template<typename Arg, size_t N, std::size_t... Is>
DEVICE_INLINE_FUNCTION auto TempLat::reverse_array (
    const device::array< Arg, N > & array,
    std::index_sequence< Is... >
) 

---

function reverse_array

template<typename Arg, size_t N>
DEVICE_INLINE_FUNCTION auto TempLat::reverse_array (
    const device::array< Arg, N > & array
) 

---

function reverse_tuple

template<typename... Args, std::size_t... Is>
DEVICE_INLINE_FUNCTION auto TempLat::reverse_tuple (
    const device::tuple< Args... > & tuple,
    std::index_sequence< Is... >
) 

---

function reverse_tuple

template<typename... Args>
DEVICE_INLINE_FUNCTION auto TempLat::reverse_tuple (
    const device::tuple< Args... > & tuple
) 

---

function safeDivide

template<typename R, typename T>
auto TempLat::safeDivide (
    const R & r,
    const T & t
) 

@vocab-summary Division that yields exactly zero where the numerator does, instead of evaluating 0/0. Written for normalising spectra against a cutoff. @vocab-signature safeDivide(numerator, denominator)

---

function safeSqrt

template<typename R>
auto TempLat::safeSqrt (
    const R & r
) 

@vocab-summary Square root that clamps a negative argument to zero, for quantities that are positive up to rounding.

---

function scalar_prod

template<class R, class T>
auto TempLat::scalar_prod (
    const R & r,
    const T & t
) 

@vocab-summary Scalar product of two SU(2) doublets.

---

function scalar_prod

template<class R>
auto TempLat::scalar_prod (
    const R & r,
    ZeroType t
) 

---

function scalar_prod

template<class R>
auto TempLat::scalar_prod (
    ZeroType t,
    const R & r
) 

---

function sh1

template<class R>
auto TempLat::sh1 (
    const R & pR
) 

---

function sh1

template<int I, int... J, class R>
auto TempLat::sh1 (
    const R & pR
) 

---

function shift

template<int... shifts, class R>
auto TempLat::shift (
    const R & pR
) 

---

function shift

template<int N, class R>
auto TempLat::shift (
    const R & pR
) 

---

function shift

template<class R, int N>
auto TempLat::shift (
    const R & pR,
    Tag < N > t
) 

---

function shift

template<typename R, int... N>
auto TempLat::shift (
    const R & r
) 

---

function shift

template<class R, int N>
auto TempLat::shift (
    const R & pR,
    const Tag < N > & t
) 

---

function shift

template<int... shifts, class R>
auto TempLat::shift (
    const R & pR
) 

---

function shift

template<int N, class R>
auto TempLat::shift (
    const R & pR
) 

---

function shift

template<class R, int N>
auto TempLat::shift (
    const R & pR,
    Tag < N > t
) 

---

function shift

template<int... shifts, class R>
auto TempLat::shift (
    const R & pR
) 

@vocab-summary Reads an expression at a site offset by a constant lattice vector: shift(phi, 1_c) is \(\phi(x+\hat e\_1)\). Every finite-difference operator is built from it, and it is what tells TempLat which ghost cells to exchange. @vocab-signature shift(expr, mu) shift<i,j,k>(expr) @vocab-example auto p = (Us(mu) * shift(Us(nu), mu)) * dagger(shift(Us(mu), nu)) * dagger(Us(nu));

---

function shift

template<int N, class R>
auto TempLat::shift (
    const R & pR
) 

---

function shift

template<class R, int N>
auto TempLat::shift (
    const R & pR,
    Tag < N > t
) 

---

function shift

template<int N>
constexpr OneType TempLat::shift (
    OneType
) 

---

function shift

template<int N>
constexpr OneType TempLat::shift (
    OneType,
    Tag < N >
) 

---

function shift

template<int N>
constexpr ZeroType TempLat::shift (
    ZeroType
) 

---

function shift

template<int N>
constexpr ZeroType TempLat::shift (
    ZeroType,
    Tag < N >
) 

---

function shift

template<int... shifts, class R>
auto TempLat::shift (
    const R & pR
) 

---

function shift

template<int N, class R>
auto TempLat::shift (
    const R & pR
) 

---

function shift

template<int N, class R>
auto TempLat::shift (
    const R & pR,
    Tag < N > t
) 

---

function shift

template<int... shifts, class R>
auto TempLat::shift (
    const R & pR
) 

---

function shift

template<int N, class R>
auto TempLat::shift (
    const R & pR
) 

---

function shift

template<class R, int N>
auto TempLat::shift (
    const R & pR,
    Tag < N > t
) 

---

function shifted_index_sequence

Use as shifted_index_sequence<SHIFT>(std::make_index_sequence<N>{}) To get an index sequence<SHIFT,SHIFT+1,...,SHIFT+N-1>

template<int SHIFT, size_t... I>
auto TempLat::shifted_index_sequence (
    std::index_sequence< I... >
) 

Unit test: ctest -R test-shiftedindexsequence

---

function sin

Exposing our newly define exp operation to the world.

template<typename T>
auto TempLat::sin (
    T a
) 

@vocab-summary Sine, element-wise.

---

function sin

Specialize for possible zero input!

inline constexpr ZeroType TempLat::sin (
    ZeroType a
) 

---

function sinh

Exposing our newly define exp operation to the world.

template<typename T>
auto TempLat::sinh (
    T a
) 

@vocab-summary Hyperbolic sine, element-wise.

---

function sinh

Specialize for possible zero input!

inline constexpr ZeroType TempLat::sinh (
    ZeroType a
) 

---

function sqrt

template<typename R>
ListPower < R, HalfType > TempLat::sqrt (
    const R & r
) 

---

function sqrt

template<typename T>
auto TempLat::sqrt (
    T a
) 

@vocab-summary Square root, built as \(x^{1/2}\) so the expression stays symbolically differentiable.

---

function sqrt

Specialize for possible zero input!

inline constexpr ZeroType TempLat::sqrt (
    ZeroType a
) 

---

function sqrt

Specialize for possible unit input!

inline constexpr OneType TempLat::sqrt (
    OneType a
) 

---

function su2average

template<typename T>
auto TempLat::su2average (
    T instance,
    SpaceStateType spaceType=IsComplexType< typename SU2GetGetReturnType < T >::type > ? SpaceStateType::Fourier :SpaceStateType::Configuration
) 

@vocab-summary Lattice average of an SU(2)-valued expression, aware of cached link operations.

---

function su2dotter

template<class R, class T>
auto TempLat::su2dotter (
    const R & r,
    const T & t
) 

@vocab-summary Lie-algebra inner product \(\langle A,B\rangle = \sum\_{a=1}^{3} A\_a B\_a\), evaluated in one fused pass rather than by building three component expressions.

---

function su2doubletaverage

template<typename T>
auto TempLat::su2doubletaverage (
    T instance,
    SpaceStateType spaceType=IsComplexType< typename SU2DoubletGetGetReturnType < T >::type > ? SpaceStateType::Fourier :SpaceStateType::Configuration
) 

@vocab-summary Lattice average of an SU(2) doublet expression. @vocab-tags SU2Doublet

---

function sum_in_range

A function which applies + to the results of func(Tag<i>()) for i in [begin, end).

template<int begin, int end, typename F>
constexpr auto TempLat::sum_in_range (
    F && func
) 

Unit test: ctest -R test-sum_in_range

Parameters:

• func the function to apply to each integer in the range before summing

---

function sum_in_range_impl

template<int begin, typename F, int... INT>
constexpr auto TempLat::sum_in_range_impl (
    F && func,
    std::integer_sequence< int, INT... > iseq
) 

---

function symTracelessFieldAsFourier

template<typename R>
SymTracelessFieldAsFourier < R > TempLat::symTracelessFieldAsFourier (
    R && r
) 

@vocab-summary Views a symmetric-traceless field in Fourier space. @vocab-tags SymTraceless, Fourier

---

function tag_value

template<int N>
consteval int TempLat::tag_value (
    Tag < N >
) 

---

function tanh

Exposing our newly define exp operation to the world.

template<typename T>
auto TempLat::tanh (
    T a
) 

@vocab-summary Hyperbolic tangent, element-wise.

---

function tanh

Specialize for possible zero input!

inline constexpr ZeroType TempLat::tanh (
    ZeroType a
) 

---

function toSU2

template<class R>
auto TempLat::toSU2 (
    R r
) 

@vocab-summary Projects an SU(2)-valued expression onto the group by rebuilding it from its three vector components.

---

function to_int

A class which implements a litteral to create tags, comes from Boost Hana.

constexpr int TempLat::to_int (
    char c
) 

Unit test: ctest -R test-tagliteral

---

function to_string

std::string TempLat::to_string (
    EvolverType eType
) 

---

function total

Sums all the components of a tuple after applying func to them.

template<class Tuple, typename Function>
constexpr auto TempLat::total (
    Tuple && tup,
    Function && func
) 

Unit test: ctest -R test-total

Parameters:

• tup the tuple to sum over
• func the function to apply to each component before summing

@vocab-summary Sums every component of a tuple-like expression, optionally applying a function to each first. Reduces over the components, not over the lattice. @vocab-signature total(tup) total(tup, f)

---

function total

Sums all the components of a tuple.

template<class Tuple>
constexpr auto TempLat::total (
    Tuple && tup
) 

Unit test: ctest -R test-total

Parameters:

• tup the tuple to sum over

---

function total_impl

template<typename Tuple, typename F, int... INT>
constexpr auto TempLat::total_impl (
    Tuple && tup,
    F && func,
    std::integer_sequence< int, INT... > iseq
) 

---

function trace

A function which takes the trace of su2 matrices.

template<typename R>
auto TempLat::trace (
    R && r
) 

Unit test: ctest -R test-su2trace

@vocab-summary Trace of an SU(2) matrix, \(\mathrm{tr}\,U = 2c\_0\) in the four-real-component representation.

---

function trace

inline constexpr auto TempLat::trace (
    ZeroType r
) 

---

function tuple_add_to_nth

template<size_t n, int add, typename... IDX>
DEVICE_INLINE_FUNCTION constexpr auto TempLat::tuple_add_to_nth (
    const device::tuple< IDX... > & tt
) 

---

function tuple_add_to_nth_mod

Pass a tuple of indices and add the second argument to the n-th value of the tuple.

template<size_t n, int add, typename... IDX>
DEVICE_INLINE_FUNCTION constexpr auto TempLat::tuple_add_to_nth_mod (
    device::tuple< IDX... > & tt
) 

Template parameters:

• n which index of the tuple is to be changed
• add the value to add
• IDX types of the tuple elements

Parameters:

• tt the tuple to modify

Returns:

auto the modified tuple

---

function tuple_first

Returns the first i elements of the given tuple t.

template<int i, typename Head, typename... Tail>
DEVICE_INLINE_FUNCTION constexpr auto TempLat::tuple_first (
    const device::tuple< Head, Tail... > & t
) 

Template parameters:

• i size of the tuple to be returned

Parameters:

• t tuple to be split

Returns:

auto a tied tuple of the first i elements

---

function tuple_last

Returns the last i elements of the given tuple t.

template<size_t i, typename Head, typename... Tail>
DEVICE_INLINE_FUNCTION constexpr auto TempLat::tuple_last (
    const device::tuple< Head, Tail... > & t
) 

Template parameters:

• i size of the tuple to be returned

Parameters:

• t tuple to be split

Returns:

auto a tied tuple of the last i elements

---

function wallAverager

template<typename T>
auto TempLat::wallAverager (
    T instance,
    SpaceStateType spaceType=SpaceStateType::Configuration
) 

@vocab-summary Averages over the first \(d-1\) coordinates, leaving a profile along the last one.

---

function wallAverager

auto TempLat::wallAverager (
    ZeroType a
) 

---

Public Static Functions Documentation

function getComponent

A class which returns imaginary part of a fields or symmetric-traceless number.

template<class T, int I>
static auto TempLat::getComponent (
    T && t,
    Tag < I > i
) 

Unit test: ctest -R test-imag

---

function getComponent

template<class T, int I>
static auto TempLat::getComponent (
    T && t,
    Tag < I > i
) 

---

function getComponent

template<class T, int I>
static auto TempLat::getComponent (
    T && t,
    Tag < I > i
) 

---

function getComponent

template<class T, int I>
static auto TempLat::getComponent (
    T && t,
    Tag < I > i
) 

---

function getComponent

template<class T, int I, int J>
static auto TempLat::getComponent (
    T && t,
    Tag < I > i,
    Tag < J > j
) 

---

function getComponent

template<class T, int I, int J>
static auto TempLat::getComponent (
    T && t,
    Tag < I > i,
    Tag < J > j
) 

---

function getComponent

template<class T, int I, int J>
static auto TempLat::getComponent (
    T && t,
    Tag < I > i,
    Tag < J > j
) 

---

function getComponent

template<class T, int I, int J>
static auto TempLat::getComponent (
    T && t,
    Tag < I > i,
    Tag < J > j
) 

---

function getFFTSessionGuards

static inline std::vector< std::shared_ptr< FFTSessionGuard > > TempLat::getFFTSessionGuards (
    bool pVerbose=true
) 

---

---

The documentation for this class was generated from the following file cosmolatticeweb/tmp/code_source/templat/include/TempLat/fft/external/fftw/fftwguard.h