Provides a tensor with taking advantage of possibly low rank. More...
#include <madness/tensor/tensor.h>#include <madness/tensor/srconf.h>#include <madness/tensor/tensortrain.h>#include <stdexcept>
Go to the source code of this file.
Classes | |
| singleton | madness::SliceGenTensor< T > |
| singleton | madness::GenTensor< T > |
| struct | madness::TensorArgs |
| TensorArgs holds the arguments for creating a LowRankTensor. More... | |
| singleton | madness::GenTensor< T > |
| struct | madness::archive::ArchiveStoreImpl< Archive, GenTensor< T > > |
| Serialize a tensor. More... | |
| struct | madness::archive::ArchiveLoadImpl< Archive, GenTensor< T > > |
| Deserialize a tensor ... existing tensor is replaced. More... | |
Namespaces | |
| madness | |
| Holds machinery to set up Functions/FuncImpls using various Factories and Interfaces. | |
| madness::archive | |
Functions | |
| template<typename T > | |
| bool | madness::has_zero_rank (const GenTensor< T > &g) |
| true if GenTensor has zero rank or no data More... | |
| template<class T > | |
| GenTensor< T > | madness::reduce (std::list< GenTensor< T > > &addends, double eps, bool are_optimal=false) |
| template<class T > | |
| GenTensor< T > | madness::outer (const GenTensor< T > &left, const GenTensor< T > &right) |
| Outer product ... result(i,j,...,p,q,...) = left(i,k,...)*right(p,q,...) More... | |
| template<class T > | |
| GenTensor< T > | madness::outer_low_rank (const Tensor< T > &left, const Tensor< T > &right) |
| Outer product ... result(i,j,...,p,q,...) = left(i,k,...)*right(p,q,...) More... | |
| template<typename T > | |
| void | madness::change_tensor_type (GenTensor< T > &t, const TensorArgs &targs) |
| change representation to targ.tt More... | |
| template<class T , class Q > | |
| GenTensor< TENSOR_RESULT_TYPE(T, Q)> | madness::general_transform (const GenTensor< T > &t, const Tensor< Q > c[]) |
| Transform all dimensions of the tensor t by distinct matrices c. More... | |
| template<class T > | |
| GenTensor< T > | madness::general_transform (const GenTensor< T > &t, const Tensor< T > c[]) |
| template<typename T , typename Q > | |
| IsSupported< TensorTypeData< Q > , GenTensor< T > >::type | madness::operator* (const Q &x, const GenTensor< T > &t) |
| The class defines tensor op scalar ... here define scalar op tensor. More... | |
Detailed Description
Provides a tensor with taking advantage of possibly low rank.
MAIN DIFFERENCES (Tensor t; GenTensor g) t=t1(s) is shallow g=g1(s) is deep
a GenTensor is a generalized form of a Tensor for now only little functionality shall be implemented; feel free to extend a consequence is that we (usually) can't directly access individual matrix elements note that a GenTensor might have zero rank, but is still a valid tensor, and should therefore return a FullTensor with zeros in it.
- Slicing in GenTensors:
A GenTensor differs from a Tensor in that we can't directly access individual matrix elements, and thus can't directly assign or manipulate slices as lvalues. For rvalues we simply provide a slices of the constituent vectors in SRConf, which is a valid GenTensor by itself
Manipulations of slices of a GenTensor are heavily restricted, but should cover the most important cases:
- assignment to zero; done by inplace subtraction of the slice GenTensor lrt1(t);lrt1(s) = 0.0;
- in-place addition GenTensor lrt1(3,3,3,3), lrt2(t);lrt1(s) += lrt2;
Note that all of these operation increase the rank of lhs
- Addition in GenTensors
Addition in a GenTensor is a fairly complicated issue, and there are several algorithms you can use, each with certain pros and cons
- append() plain concatenating of the configurations will increase the rank and will introduce linear dependencies and redundancies. Also, you might have to reallocate memory and copy a lot of data around. However, no accuracy is lost and it is fairly fast. Final rank reduction might be expensive, since you might have accumulated a huge amount of terms.
- low_rank_add_sequential() only for SVD (2-way decomposition) take the 2nd vector as a basis of a vector space, project the overlap of the old and new terms on the lhs basis, perform modified Gram-Schmidt orthogonalization on the rhs basis and increase the basis if necessary. This will require the left hand side to be right-orthonormal, and the caller is responsible for doing that. If a new GenTensor is created and only additions using this method are performed the tensor will automatically be orthonormal. Cost depends on the number of terms of the rhs and the lhs
- addition of slices as of now we can add slices only using append()
- addition in full rank form at times it might be sensible to accumulate your result in a full rank tensor, and after collecting all the contribution you can transform it into a low rank tensor. This will also maintain "all" digits, and cost depends not on the number of terms on the lhs.
