sisi4s
Loading...
Searching...
No Matches
Namespaces | Classes | Typedefs | Enumerations | Functions
sisi4s Namespace Reference

Namespaces

namespace  cc4s
 

Classes

class  Algorithm
 
class  AlgorithmFactory
 
class  AlgorithmRegistrar
 Class to be statically instantiated by an algorithm to register it in the AlgorithmFactory. Registered algorithms can be instantiated from the sisi4s control language. More...
 
class  AlternatingLeastSquaresRegularizationEstimator
 
class  ApproximateCoulombVertex
 
class  ApproximateParticleHoleCoulombVertex
 
class  Argument
 
class  BasisSetExtrapolation
 
class  BinaryTensorDimensionHeader
 
class  BinaryTensorHeader
 
class  BinaryTensorHeaderBase
 
class  BlacsWorld
 
class  BooleanData
 
class  CcsdDiagrammaticDecomposition
 
class  CcsdEnergyFromCoulombIntegrals
 Implements the iteration routine for the Ccsd method. Calculates the amplitudes $T_{a}^{i}$ and $T_{ab}^{ij}$ from the Coulomb integrals $V_{ij}^{ab}, V_{bj}^{ai}, V_{kl}^{ij}, V_{ka}^{ij}, V_{ci}^{ab}$ and $V_{cd}^{ab}$ (if given, else slicing and the Coulomb Vertex $\Gamma_{pG}^q$ is used). More...
 
class  CcsdEnergyFromCoulombIntegralsReference
 Implements the iteration routine for the Ccsd method. Calculates the amplitudes $T_{a}^{i}$ and $T_{ab}^{ij}$ from the Coulomb integrals $V_{ij}^{ab}, V_{bj}^{ai}, V_{kl}^{ij}, V_{ka}^{ij}, V_{ci}^{ab}$ and $V_{cd}^{ab}$ (if given, else slicing and the Coulomb Vertex $\Gamma_{pG}^q$ is used). More...
 
class  CcsdEquationOfMotionDavidson
 
class  CcsdPerturbativeTriples
 Caclulates perturbative triples correction. More...
 
class  CcsdPerturbativeTriplesComplex
 Caclulates perturbative triples correction. More...
 
class  CcsdPreconditioner
 Implements the diagonal preconditionar for the davidson method. More...
 
class  CcsdtEnergyFromCoulombIntegrals
 
class  CcsdtEquationOfMotionDavidson
 
class  CisOneBodyReducedDensityMatrix
 
class  CISPreconditioner
 
class  ClusterSinglesDoublesAlgorithm
 Contains all the necessary tools for an algorithm with singles and doubles amplitudes. It calculates the energy from the amplitudes $T_{a}^{i}$ and $T_{ab}^{ij}$ and the Coulomb integrals $V_{ij}^{ab}$. For calculating the amplitudes it calls the iteration routine of the actual algorithm. More...
 
class  ClusterSinglesDoublesTriplesAlgorithm
 Contains all the necessary tools for an algorithm with singles, doubles and triples amplitudes. It calculates the energy from the amplitudes $T_{a}^{i}$, $T_{ab}^{ij}$ $T_{abc}^{ijk}$ and the Coulomb integrals $V_{ij}^{ab}$. For calculating the amplitudes it calls the iteration routine of the actual algorithm. More...
 
class  ClusterSinglesDoublesTriplesQuadruplesAlgorithm
 Contains all the necessary tools for an algorithm with singles, doubles and triples amplitudes. It calculates the energy from the amplitudes $T_{a}^{i}$, $T_{ab}^{ij}$ $T_{abc}^{ijk}$ and the Coulomb integrals $V_{ij}^{ab}$. For calculating the amplitudes it calls the iteration routine of the actual algorithm. More...
 
class  ComplexTensorContraction
 
class  ComplexTensorNorm
 
class  ComplexTensorReader
 
class  ComplexTensorSum
 
class  ComplexTensorWriter
 
class  ComplexTraits
 
class  ComplexTraits< Complex< T > >
 
struct  ContainerData
 
class  Conversion
 
class  Conversion< Real, Complex< Real > >
 
class  Conversion< Target, Complex< Real > >
 
class  CoulombIntegralsFromGaussian
 
class  CoulombIntegralsFromRotatedCoulombIntegrals
 
class  CoulombIntegralsFromVertex
 Caclulates the Coulomb Integrals $V_{ij}^{ab}, V_{bj}^{ai}, V_{kl}^{ij}, V_{cd}^{ab}, V_{ka}^{ij}, V_{ci}^{ab}$ (if given) from the Coulomb Vertex $\Gamma_{rG}^q$ and stores them in CTF Tensors Vabij, Vaibj, Vijkl, Vabcd, Vijka, and Vabci respectively. The arguments of the integrals are PPPP, PPHH, HHHH, PHPH, HHHP, and PPPHCoulombIntegrals. More...
 
class  CoulombVertexDecomposition
 Decomposes the Coulomb vertex $\Gamma_{rG}^q$ into the factor orbitals $\Pi_{qR}$ and the Coulom factors $\Lambda_{GR}$. The decomposition is done with a regularized alternating least squares (RALS) algorithm, requiring only a few dozen steps for sufficient convergence. Note that currently the employed fit is $\Pi_{qR}\Pi_{rR}\Lambda_{GR}$ rather than the form with $\Pi_{qR}$ conjugated. More...
 
class  CoulombVertexFromFactors
 Caclulates the Coulomb vertex $\Gamma^q_{rF}$ from the given given factor orbitals $\Pi^R_r$ and Coulomb factors $\Lambda^R_F$. More...
 
class  CoulombVertexReader
 Reads the Coulomb vertex $\Gamma_{pG}^q$ and the occupied and virtual orbital energies $\varepsilon_i, \varepsilon_a$ from binary data file, and stores them in the CTF Tensors GammaGqr, epsi, epsa. More...
 
class  CoulombVertexSingularVectors
 
class  CtfMachineTensor
 
class  CtfMachineTensorFactory
 
class  Data
 
class  DefaultRandomEngine
 
class  DefineHolesAndParticles
 
class  Delete
 
class  DetailedException
 
class  DiisMixer
 
class  DoublesAmplitudesDecomposition
 
class  DoublesAmplitudesFromVertex
 Caclulates the doubles amplitudes $T_{ij}^{ab}$ from the doubles amplitudes Vertex $Y^a_{iL}$. More...
 
class  DrccdEnergyFromCoulombIntegrals
 Implements the iteration routine for the Drccd method. Calculates the amplitudes $T_{ab}^{ij}$ from the Coulomb Integrals $V_{ij}^{ab}$ in a $ \mathcal{O}(N^{6}) $ implementation. More...
 
class  DryIterativePseudoInverse
 
class  DryMatrix
 
class  DryMemory
 
class  DryPseudoInverseHermitianSvd
 
class  DryPseudoInverseSvd
 
class  DryScalar
 
class  DryTensor
 
class  DryVector
 
class  EACcsdPreconditioner
 
class  EigenSystemDavidson
 
class  EigenSystemDavidsonMono
 
class  Emitter
 Class with static members offering control over yaml emitting. Entries are emitted with the macro EMIT. More...
 
class  EomOneBodyReducedDensityMatrix
 This implements one body rdm for eom ccsd In principle it calculates p T <0| L \rho R e |0> q For L and R being singles doubles vectors without 0-th components. More...
 
class  Exception
 
class  Exit
 
class  FcidumpReader
 
class  FcidumpWriter
 
class  FiniteSizeCorrection
 
class  FloatTypes
 
class  FloatTypes< 32 >
 
class  FloatTypes< 64 >
 
class  FlopsCounter
 
struct  FockMatrixFromCoulombIntegrals
 
class  FockVector
 Represents the direct sum of Tensors and provides the vector space operations of addition, scalar multiplication, inner product, complex conjugation to get dual vectors and matrix multiplication between vectors and duals, which yields a scalar. More...
 
class  FockVectorNdCanonical
 
class  FromComplexTensor
 
class  GenerateRandomComplexMatrix
 
class  GenerateRandomMatrix
 
class  GenerateRandomTensor
 
class  HartreeFockFromCoulombIntegrals
 
class  HartreeFockFromGaussian
 
struct  IJKPointer
 Caclulates perturbative triples correction, third attemp. More...
 
class  InputFileParser
 Parser for sisi4s files specifying the calculation plan, i.e. which algorithms to use in which order. More...
 
class  InputFileParser< InputFileFormat::CC4S >
 
class  InputFileParser< InputFileFormat::YAML >
 
class  IntegerData
 
struct  IntegralInfo
 
class  Inter1D
 
class  IPCcsdPreconditioner
 
struct  IrmlerTensor
 
class  IterativePseudoInverse
 
class  LapackGeneralEigenSystem
 
class  LapackGeneralEigenSystem< complex >
 
class  LapackGeneralEigenSystem< double >
 
class  LapackInverse
 
class  LapackInverse< Complex64 >
 
class  LapackMatrix
 
class  LinearMixer
 
class  LineNumberStream
 Wrapper for an input stream providing tracking of the current line and the current column during stream reading. More...
 
class  Log
 Class with static members offering control over logging. Log entries are created with the macro LOG. More...
 
class  LogBuffer
 
class  LogStream
 
class  Map
 
struct  MeanCorrelationHoleDepth
 
class  Mixer
 
class  MixerFactory
 
class  MixerRegistrar
 Class to be statically instantiated by a mixer to register it in the MixerFactory. Registered mixers can be instantiated from the sisi4s control language. More...
 
class  MoReader
 
class  Mp2NaturalOrbitals
 Caclulates MP2 natural orbitals. More...
 
class  MpiCommunicator
 
class  MpiTypeTraits
 
class  MpiTypeTraits< complex >
 
class  MpiTypeTraits< double >
 
class  MpiTypeTraits< int >
 
class  MpiTypeTraits< int64_t >
 
class  MpiTypeTraits< uint64_t >
 
class  MpiTypeTraits< Vector< F, D > >
 
struct  NaturalTransitionOrbitalsFromRhoAI
 
class  Nop
 
class  NoRegularizationEstimator
 
class  NuclearRepulsionEnergy
 
class  NumberScanner
 
class  NumberScanner< Complex< Real > >
 
class  NumberScanner< Float64 >
 
class  NumericData
 
class  OneBodyFromGaussian
 
class  OneBodyReducedDensityMatrix
 
class  OneBodyRotation
 
struct  Options
 
class  ParenthesisTriples
 
class  ParticleHoleCoulombVertexDecomposition
 Decomposes the particle hole Coulomb vertex $\Gamma_{iG}^a$ into the occupied factor orbitals $\Pi_{iR}$, the virtual factor orbitals $\Pi_{aR}$, and the Coulom factors $\Lambda_{GR}$. The decomposition is done with a regularized alternating least squares (RALS) algorithm, requiring only a few dozen steps for sufficient convergence. More...
 
class  ParticleHoleCoulombVertexFromFactors
 Caclulates the particle hole Coulomb vertex $\Gamma^a_{iF}$ from the given given particle factors orbitals $\Pi^R_a$, hole factor orbitals $\Pi^R_i$ and Coulomb factors $\Lambda^R_F$. More...
 
class  ParticleHoleCoulombVertexReader
 Reads the particle-hole Coulomb vertex $\Gamma_{iG}^a$ and the occupied and virtual orbital energies $\varepsilon_i, \varepsilon_a$ from binary data file, and stores them in the CTF Tensors GammaGai, epsi, epsa. More...
 
class  ParticleHoleCoulombVertexSingularVectors
 
class  Permutation
 
class  Permutation< 1 >
 
class  PerturbativeTriples
 Caclulates perturbative triples correction. More...
 
class  PQRSCoulombIntegralsToVertex
 
class  Preconditioner
 
class  PseudoInverse
 
class  PseudoInverseHermitianSvd
 
class  PseudoInverseSvd
 
class  RandomGenerator
 
class  RangeParser
 Class to parse a string of comma separated range delimiters. Note: It only works for unsigned integers. More...
 
class  Read
 
class  RealData
 
class  ScaLapackDescriptor
 
class  ScaLapackHermitianEigenSystem
 
class  ScaLapackHermitianEigenSystem< complex >
 
class  ScaLapackHermitianEigenSystem< double >
 
class  ScaLapackHermitianEigenSystemDc
 
class  ScaLapackHermitianEigenSystemDc< complex >
 
class  ScaLapackHermitianEigenSystemDc< double >
 
class  ScaLapackMatrix
 
class  ScaLapackSingularValueDecomposition
 
class  ScaLapackSingularValueDecomposition< complex >
 
class  ScaLapackSingularValueDecomposition< double >
 
class  Scanner
 
class  SDFockVector
 
class  SDTFockVector
 
class  SFockVector
 
class  SimilarityTransformedHamiltonian
 
class  simpson
 
class  SingleParticleOccupancies
 Evaluates $\langle\Psi|\hat N_p|\Psi\rangle/\langle\Psi|\Psi\rangle$ given the DoublesAmplitudes from a linearized coupled cluster theory. More...
 
class  Sisi4s
 
class  SliceCoulombVertex
 Slices the particle hole part $\Gamma^{aG}_i$ from the full Coulomb vertex $\Gamma^{qG}_r$. More...
 
class  SlicedCtfTensor
 
class  SourceLocation
 
class  StantonIntermediatesUCCSD
 
class  StaticAssert
 
class  TensorAntisymmetrizer
 
class  TensorAntisymmetrizer2
 
class  TensorContraction
 
class  TensorData
 
class  TensorGetMax
 
class  TensorIo
 
class  TensorNorm
 
class  TensorReader
 
struct  TensorReduceijij
 
struct  TensorSlicer
 
class  TensorSum
 
class  TensorUnrestricter
 
class  TensorWriter
 
class  TextData
 
class  Time
 
class  Timer
 
class  trapezium
 
class  TypedData
 
class  TypeRelations
 
class  TypeRelations< A *, A >
 
class  TypeRelations< A, A >
 
class  TypeRelations< double, complex >
 
class  TypeRelations< int, complex >
 
class  TypeRelations< int, double >
 
class  TypeTraits
 
class  TypeTraits< bool >
 
class  TypeTraits< Complex64 >
 
class  TypeTraits< Float64 >
 
class  TypeTraits< int64_t >
 
class  UccsdAmplitudesFromCoulombIntegrals
 
class  UCcsdEAEquationOfMotionDavidson
 
class  UCcsdIPEquationOfMotionDavidson
 
class  UccsdtAmplitudesFromCoulombIntegrals
 
class  UccsdtqAmplitudesFromCoulombIntegrals
 
class  UegVertexGenerator
 
class  UnrestrictedCIS
 
class  UnrestrictedEquationOfMotionSinglesFromRpa
 
class  UPerturbativeTriples
 Caclulates perturbative triples correction. More...
 
class  UrpaAmplitudesFromCoulombIntegrals
 
class  Vector
 
struct  VectorTensor
 
class  Write
 

Typedefs

using MatrixColumnMajor = Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor >
 
using ivec = std::array< int, 3 >
 
using dvec = std::array< double, 4 >
 
template<typename Real >
using Complex = std::complex< Real >
 
typedef Complex< Float32 > Complex32
 
typedef Complex< Float64 > Complex64
 
typedef Complex< real > complex
 
typedef FloatTypes< 32 >::type Float32
 
typedef FloatTypes< 64 >::type Float64
 
template<typename F >
using CISFockVector = FockVectorNdCanonical< F, 1, 0 >
 
template<typename F >
using CISDFockVector = FockVectorNdCanonical< F, 2, 0 >
 
template<typename F >
using CISDTFockVector = FockVectorNdCanonical< F, 3, 0 >
 
template<typename F >
using Tensor = CTF::Tensor< F >
 
using TensorIndex = int64_t
 
template<typename F >
using Matrix = CTF::Matrix< F >
 

Enumerations

enum  InputFileFormat { YAML , CC4S }
 
enum  Index { NO , NV , NP }
 

Functions

template<typename AlgorithmType >
Algorithm * createAlgorithm (std::vector< Argument > const &arguments)
 template function creating an instance of the given class.
 
template<int N>
std::string operator* (const std::string &s, const sisi4s::Permutation< N > &pi)
 
MatrixColumnMajor toEigenMatrix (Tensor< double > &ctf)
 
template<typename F = double>
void composeCanonicalPolyadicDecompositionTensors (Tensor< F > &A, Tensor< F > &B, Tensor< F > &C, Tensor< F > &T)
 Calculates $T_{ijk}=A_{iR}B_{jR}C_{kR}$ with minimal memory footprint.
 
template<typename F = double>
void dryComposeCanonicalPolyadicDecompositionTensors (DryTensor< F > &A, DryTensor< F > &B, DryTensor< F > &C, DryTensor< F > &T)
 Performs a dry run of the calculation $T_{ijk}=A_{iR}B_{jR}C_{kR}$ with minimal memory footprint.
 
template<typename F = double>
void contractWithCanonicalPolyadicDecompositionTensors (Tensor< F > &T, char const *indicesT, Tensor< F > &B, char const idxB, Tensor< F > &C, char const idxC, Tensor< F > &A, char const idxA)
 Calculates $A_{iR} = T_{ijk}B^{jR}C^{kR}$ using a contraction order with minimal memory footprint.
 
template<typename F = double>
void dryContractWithCanonicalPolyadicDecompositionTensors (DryTensor< F > &T, char const *indicesT, DryTensor< F > &B, char const idxB, DryTensor< F > &C, char const idxC, DryTensor< F > &A, char const idxA)
 Performs a dry run of the calculation $A_{iR} = T_{ijk}B^{jR}C^{kR}$ using a contraction order with minimal memory footprint.
 
template<typename Real >
Real absSqr (const Real x)
 
template<typename Real >
Real absSqr (const Complex< Real > z)
 
void fromComplexTensor (Tensor< complex > &c, Tensor< double > &r, Tensor< double > &i)
 Decomposes the tensor of complex elements into two tensors containing the real and imaginary parts, respectively.
 
void fromComplexTensor (Tensor< double > &c, Tensor< double > &r, Tensor< double > &i)
 
void fromComplexTensor (Tensor< complex > &c, Tensor< double > &r)
 Discards the real part of a complex tensor.
 
void toComplexTensor (Tensor< double > &r, Tensor< double > &i, Tensor< complex > &c)
 Composes a tensor of complex elements containing of the given tensors of real and imaginary parts. Note that in this overload the imaginary part may be redistributed during reading.
 
void toComplexTensor (Tensor< double > &r, Tensor< complex > &c)
 
void toComplexTensor (Tensor< double > &r, Tensor< double > &c)
 
void conjugate (Tensor< double > &c)
 
void conjugate (Tensor< complex > &c)
 
template<typename F >
FockVector< F > operator+ (const FockVector< F > &a, const FockVector< F > &b)
 Returns the sum of two FockVectors a and b, where neither a nor b are modified.
 
template<typename F >
FockVector< F > && operator+ (FockVector< F > &&a, const FockVector< F > &b)
 Returns the sum of two FockVectors a and b, where a is movable and will be used for the result.
 
template<typename F >
FockVector< F > && operator+ (FockVector< F > &a, const FockVector< F > &&b)
 Returns the sum of two FockVectors a and b, where b is movable and will be used for the result.
 
template<typename F >
FockVector< F > operator- (const FockVector< F > &a, const FockVector< F > &b)
 Returns the difference between two FockVectors a and b, where neither a nor b are modified.
 
template<typename F >
FockVector< F > && operator- (FockVector< F > &&a, const FockVector< F > &b)
 Returns the difference between two FockVectors a and b, where a is movable and will be used for the result.
 
template<typename F >
FockVector< F > && operator- (const FockVector< F > &a, FockVector< F > &&b)
 Returns the difference between two FockVectors a and b, where b is movable and will be used for the result.
 
template<typename F >
FockVector< F > operator* (const FockVector< F > &a, const F s)
 Returns the scalar multiple of the FockVector a right-multiplied with the scalar s, where a is not modified.
 
template<typename F >
FockVector< F > && operator* (FockVector< F > &&a, const F s)
 Returns the scalar multiple of the FockVector a right-multiplied with the scalar s, where a movable and will be used for the result.
 
template<typename F >
FockVector< F > operator* (const F s, const FockVector< F > &a)
 Returns the scalar multiple of the FockVector a left-multiplied with the scalar s, where a is not modified.
 
template<typename F >
FockVector< F > && operator* (const F s, FockVector< F > &&a)
 Returns the scalar multiple of the FockVector a left-multiplied with the scalar s, where a movable and will be used for the result.
 
template<typename F >
std::ostream & operator<< (std::ostream &stream, const FockVector< F > &a)
 Writes the FockVector a to the given stream and returns it for further stream operations.
 
template<typename Method , typename F , typename Float >
double integrate (F f, Float a, Float b, int steps, Method m)
 
template<typename F = double>
constexpr F Pi ()
 
template<typename F = double>
constexpr F Tau ()
 
template<typename F = double>
F sqrt (F const x)
 
template<typename F = double>
F abs (F const x)
 
template<typename F >
F conj (F const x)
 
template<>
double conj (double const x)
 
template<typename F = double>
F dot (F const x, F const y)
 
template<typename F = double>
F realDot (F const x, F const y)
 Calculates only the real part of x*conj(y).
 
template<typename F = double>
F divide (F const x, F const y)
 
template<typename F = double>
F multiply (F const x, F const y)
 
template<typename F >
double frobeniusNorm (Tensor< F > &t)
 
template<typename F >
void symmetrize (std::string indices, std::string permuted, Tensor< F > &t, F prefactor=1)
 Apply a permutation operator and antisymmetrize accordingly, e.g. antiSymmetrize(X, "abcd", "abdc") is replaced by -1 X["abcd"] = X["abcd"] + sign(abcd -> abdc) X["abdc"].
 
template<typename F >
void checkAntisymmetry (Tensor< F > &t)
 
template<int N>
std::ostream & operator<< (std::ostream &stream, const Map< N > &f)
 
template<int N>
Permutation< N > operator* (const Permutation< N > &, const Permutation< N > &)
 
template<int N>
Permutation< N > operator/ (const Permutation< N > &, const Permutation< N > &)
 
template<int N>
Permutation< N > operator/ (const int, const Permutation< N > &)
 
template<int N>
Map< N > operator* (const Map< N > &f, const Permutation< N > &tau)
 
template<typename Distribution , typename RandomEngine >
void setRandom (double &value, Distribution &distribution, RandomEngine &randomEngine)
 
template<typename Distribution , typename RandomEngine >
void setRandom (complex &value, Distribution &distribution, RandomEngine &randomEngine)
 
template<typename F , typename Distribution , typename RandomEngine >
void setRandomTensor (Tensor< F > &t, Distribution &distribution, RandomEngine &randomEngine)
 
template<typename F = double>
void fitAlternatingLeastSquaresFactor (Tensor< F > &T, char const *indicesT, Tensor< F > &B, char const idxB, Tensor< F > &C, char const idxC, Tensor< F > &A, char const idxA)
 
template<typename F = double>
void fitRegularizedAlternatingLeastSquaresFactor (Tensor< F > &T, char const *indicesT, Tensor< F > &B, char const idxB, Tensor< F > &C, char const idxC, Tensor< F > &A, char const idxA, AlternatingLeastSquaresRegularizationEstimator *regularizationEstimatorA)
 
template<typename F = double>
void dryFitRegularizedAlternatingLeastSquaresFactor (DryTensor< F > &T, char const *indicesT, DryTensor< F > &B, char const idxB, DryTensor< F > &C, char const idxC, DryTensor< F > &A, char const idxA)
 
template<typename F = double, int D = 3>
Vector< F, D > operator* (const F f, const Vector< F, D > &v)
 
template<typename F = double, int D = 3>
Vector< F, D > && operator* (const F f, Vector< F, D > &&v)
 
template<typename F = double, int D = 3>
std::ostream & operator<< (std::ostream &stream, sisi4s::Vector< F, D > const &v)
 
template<typename F , typename MixerType >
std::shared_ptr< Mixer< F > > createMixer (Algorithm *algorithm)
 template function creating an instance of the given class.
 
template<typename A >
A permuteIndices (const A &a, size_t i, size_t j)
 
template<typename A >
A vSym (const A &a)
 
template<typename A >
A hSym (const A &a)
 
template<typename A >
A vlSym (const A &a)
 
template<typename A >
A upTr (const A &a)
 
template<typename A >
A downTr (const A &a)
 
template<typename F = real>
LapackMatrix< F > operator* (const LapackMatrix< F > &A, const LapackMatrix< F > &B)
 
std::ostream & operator<< (std::ostream &stream, const RangeParser &parser)
 
std::ostream & operator<< (std::ostream &stream, SourceLocation const &l)
 
Time operator+ (Time const &t1, Time const &t2)
 
Time operator- (Time const &t1, Time const &t2)
 
Time operator* (const Time &difference, const double factor)
 
std::ostream & operator<< (std::ostream &stream, Time const &t)
 

Detailed Description

Provides a random number generator based on the mzran algorithm marsaglia, g. and a. zaman. 1994. some portable very-long period random number generators. computers in physics. 8(1): 117-121.

Typedef Documentation

◆ CISDFockVector

template<typename F >
using sisi4s::CISDFockVector = typedef FockVectorNdCanonical<F, 2, 0>

◆ CISDTFockVector

template<typename F >
using sisi4s::CISDTFockVector = typedef FockVectorNdCanonical<F, 3, 0>

◆ CISFockVector

template<typename F >
using sisi4s::CISFockVector = typedef FockVectorNdCanonical<F, 1, 0>

◆ Complex

template<typename Real >
using sisi4s::Complex = typedef std::complex<Real>

◆ complex

typedef Complex<real> sisi4s::complex

◆ Complex32

typedef Complex<Float32> sisi4s::Complex32

◆ Complex64

typedef Complex<Float64> sisi4s::Complex64

◆ dvec

using sisi4s::dvec = typedef std::array<double, 4>

◆ Float32

typedef FloatTypes<32>::type sisi4s::Float32

◆ Float64

typedef FloatTypes<64>::type sisi4s::Float64

◆ ivec

using sisi4s::ivec = typedef std::array<int, 3>

◆ Matrix

template<typename F >
using sisi4s::Matrix = typedef CTF::Matrix<F>

◆ MatrixColumnMajor

using sisi4s::MatrixColumnMajor = typedef Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>

◆ Tensor

template<typename F >
using sisi4s::Tensor = typedef CTF::Tensor<F>

◆ TensorIndex

using sisi4s::TensorIndex = typedef int64_t

Enumeration Type Documentation

◆ Index

enum sisi4s::Index
Enumerator
NO 
NV 
NP 

◆ InputFileFormat

enum sisi4s::InputFileFormat
Enumerator
YAML 
CC4S 

Function Documentation

◆ abs()

template<typename F = double>
F sisi4s::abs ( F const  x)
inline
Here is the caller graph for this function:

◆ absSqr() [1/2]

template<typename Real >
Real sisi4s::absSqr ( const Complex< Real >  z)
inline
Here is the call graph for this function:

◆ absSqr() [2/2]

template<typename Real >
Real sisi4s::absSqr ( const Real  x)
inline
Here is the caller graph for this function:

◆ checkAntisymmetry()

template<typename F >
void sisi4s::checkAntisymmetry ( Tensor< F > &  t)
inline

◆ composeCanonicalPolyadicDecompositionTensors()

template<typename F = double>
void sisi4s::composeCanonicalPolyadicDecompositionTensors ( Tensor< F > &  A,
Tensor< F > &  B,
Tensor< F > &  C,
Tensor< F > &  T 
)

Calculates $T_{ijk}=A_{iR}B_{jR}C_{kR}$ with minimal memory footprint.

Here is the caller graph for this function:

◆ conj() [1/2]

template<>
double sisi4s::conj ( double const  x)
inline

◆ conj() [2/2]

template<typename F >
F sisi4s::conj ( F const  x)
inline
Here is the caller graph for this function:

◆ conjugate() [1/2]

void sisi4s::conjugate ( Tensor< complex > &  c)

◆ conjugate() [2/2]

void sisi4s::conjugate ( Tensor< double > &  c)
Here is the caller graph for this function:

◆ contractWithCanonicalPolyadicDecompositionTensors()

template<typename F = double>
void sisi4s::contractWithCanonicalPolyadicDecompositionTensors ( Tensor< F > &  T,
char const *  indicesT,
Tensor< F > &  B,
char const  idxB,
Tensor< F > &  C,
char const  idxC,
Tensor< F > &  A,
char const  idxA 
)

Calculates $A_{iR} = T_{ijk}B^{jR}C^{kR}$ using a contraction order with minimal memory footprint.

Parameters
[in]Tthe tensor $T_{ijk}$
[in]indicesTthe indices to compose $T$, e.g. "ijk"
[in]Bthe tensor $B_{jR}$
[in]idxBthe index letter $B$ has in common with $T$
[in]Cthe tensor $C_{kR}$
[in]idxCthe index letter $C$ has in common with $T$
[out]Athe tensor $A_{iR}$
[in]idxAthe index letter $A$ has in common with $T$
Here is the caller graph for this function:

◆ createAlgorithm()

template<typename AlgorithmType >
Algorithm * sisi4s::createAlgorithm ( std::vector< Argument > const &  arguments)

template function creating an instance of the given class.

◆ createMixer()

template<typename F , typename MixerType >
std::shared_ptr< Mixer< F > > sisi4s::createMixer ( Algorithm *  algorithm)

template function creating an instance of the given class.

◆ divide()

template<typename F = double>
F sisi4s::divide ( F const  x,
F const  y 
)
inline

◆ dot()

template<typename F = double>
F sisi4s::dot ( F const  x,
F const  y 
)
inline
Here is the call graph for this function:
Here is the caller graph for this function:

◆ downTr()

template<typename A >
A sisi4s::downTr ( const A &  a)
Here is the call graph for this function:
Here is the caller graph for this function:

◆ dryComposeCanonicalPolyadicDecompositionTensors()

template<typename F = double>
void sisi4s::dryComposeCanonicalPolyadicDecompositionTensors ( DryTensor< F > &  A,
DryTensor< F > &  B,
DryTensor< F > &  C,
DryTensor< F > &  T 
)

Performs a dry run of the calculation $T_{ijk}=A_{iR}B_{jR}C_{kR}$ with minimal memory footprint.

Here is the caller graph for this function:

◆ dryContractWithCanonicalPolyadicDecompositionTensors()

template<typename F = double>
void sisi4s::dryContractWithCanonicalPolyadicDecompositionTensors ( DryTensor< F > &  T,
char const *  indicesT,
DryTensor< F > &  B,
char const  idxB,
DryTensor< F > &  C,
char const  idxC,
DryTensor< F > &  A,
char const  idxA 
)

Performs a dry run of the calculation $A_{iR} = T_{ijk}B^{jR}C^{kR}$ using a contraction order with minimal memory footprint.

Parameters
[in]Tthe tensor $T_{ijk}$
[in]indicesTthe indices to compose $T$, e.g. "ijk"
[in]Bthe tensor $B_{jR}$
[in]idxBthe index letter $B$ has in common with $T$
[in]Cthe tensor $C_{kR}$
[in]idxCthe index letter $C$ has in common with $T$
[out]Athe tensor $A_{iR}$
[in]idxAthe index letter $A$ has in common with $T$
Here is the caller graph for this function:

◆ dryFitRegularizedAlternatingLeastSquaresFactor()

template<typename F = double>
void sisi4s::dryFitRegularizedAlternatingLeastSquaresFactor ( DryTensor< F > &  T,
char const *  indicesT,
DryTensor< F > &  B,
char const  idxB,
DryTensor< F > &  C,
char const  idxC,
DryTensor< F > &  A,
char const  idxA 
)
Here is the call graph for this function:
Here is the caller graph for this function:

◆ fitAlternatingLeastSquaresFactor()

template<typename F = double>
void sisi4s::fitAlternatingLeastSquaresFactor ( Tensor< F > &  T,
char const *  indicesT,
Tensor< F > &  B,
char const  idxB,
Tensor< F > &  C,
char const  idxC,
Tensor< F > &  A,
char const  idxA 
)
Here is the call graph for this function:
Here is the caller graph for this function:

◆ fitRegularizedAlternatingLeastSquaresFactor()

template<typename F = double>
void sisi4s::fitRegularizedAlternatingLeastSquaresFactor ( Tensor< F > &  T,
char const *  indicesT,
Tensor< F > &  B,
char const  idxB,
Tensor< F > &  C,
char const  idxC,
Tensor< F > &  A,
char const  idxA,
AlternatingLeastSquaresRegularizationEstimator *  regularizationEstimatorA 
)
Here is the call graph for this function:
Here is the caller graph for this function:

◆ frobeniusNorm()

template<typename F >
double sisi4s::frobeniusNorm ( Tensor< F > &  t)
inline
Here is the caller graph for this function:

◆ fromComplexTensor() [1/3]

void sisi4s::fromComplexTensor ( Tensor< complex > &  c,
Tensor< double > &  r 
)

Discards the real part of a complex tensor.

◆ fromComplexTensor() [2/3]

void sisi4s::fromComplexTensor ( Tensor< complex > &  c,
Tensor< double > &  r,
Tensor< double > &  i 
)

Decomposes the tensor of complex elements into two tensors containing the real and imaginary parts, respectively.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ fromComplexTensor() [3/3]

void sisi4s::fromComplexTensor ( Tensor< double > &  c,
Tensor< double > &  r,
Tensor< double > &  i 
)

◆ hSym()

template<typename A >
A sisi4s::hSym ( const A &  a)
Here is the call graph for this function:
Here is the caller graph for this function:

◆ integrate()

template<typename Method , typename F , typename Float >
double sisi4s::integrate ( F  f,
Float  a,
Float  b,
int  steps,
Method  m 
)

◆ multiply()

template<typename F = double>
F sisi4s::multiply ( F const  x,
F const  y 
)
inline

◆ operator*() [1/11]

template<typename F = double, int D = 3>
Vector< F, D > sisi4s::operator* ( const F  f,
const Vector< F, D > &  v 
)
inline

◆ operator*() [2/11]

template<typename F = double, int D = 3>
Vector< F, D > && sisi4s::operator* ( const F  f,
Vector< F, D > &&  v 
)
inline

◆ operator*() [3/11]

template<typename F >
FockVector< F > sisi4s::operator* ( const F  s,
const FockVector< F > &  a 
)
inline

Returns the scalar multiple of the FockVector a left-multiplied with the scalar s, where a is not modified.

◆ operator*() [4/11]

template<typename F >
FockVector< F > && sisi4s::operator* ( const F  s,
FockVector< F > &&  a 
)
inline

Returns the scalar multiple of the FockVector a left-multiplied with the scalar s, where a movable and will be used for the result.

◆ operator*() [5/11]

template<typename F >
FockVector< F > sisi4s::operator* ( const FockVector< F > &  a,
const F  s 
)
inline

Returns the scalar multiple of the FockVector a right-multiplied with the scalar s, where a is not modified.

◆ operator*() [6/11]

template<typename F = real>
LapackMatrix< F > sisi4s::operator* ( const LapackMatrix< F > &  A,
const LapackMatrix< F > &  B 
)
Here is the call graph for this function:

◆ operator*() [7/11]

template<int N>
Map< N > sisi4s::operator* ( const Map< N > &  f,
const Permutation< N > &  tau 
)
inline

◆ operator*() [8/11]

template<int N>
Permutation< N > sisi4s::operator* ( const Permutation< N > &  sigma,
const Permutation< N > &  tau 
)
inline

◆ operator*() [9/11]

template<int N>
std::string sisi4s::operator* ( const std::string &  s,
const sisi4s::Permutation< N > &  pi 
)
inline

◆ operator*() [10/11]

Time sisi4s::operator* ( const Time &  difference,
const double  factor 
)
inline
Here is the call graph for this function:

◆ operator*() [11/11]

template<typename F >
FockVector< F > && sisi4s::operator* ( FockVector< F > &&  a,
const F  s 
)
inline

Returns the scalar multiple of the FockVector a right-multiplied with the scalar s, where a movable and will be used for the result.

◆ operator+() [1/4]

template<typename F >
FockVector< F > sisi4s::operator+ ( const FockVector< F > &  a,
const FockVector< F > &  b 
)
inline

Returns the sum of two FockVectors a and b, where neither a nor b are modified.

◆ operator+() [2/4]

template<typename F >
FockVector< F > && sisi4s::operator+ ( FockVector< F > &&  a,
const FockVector< F > &  b 
)
inline

Returns the sum of two FockVectors a and b, where a is movable and will be used for the result.

◆ operator+() [3/4]

template<typename F >
FockVector< F > && sisi4s::operator+ ( FockVector< F > &  a,
const FockVector< F > &&  b 
)
inline

Returns the sum of two FockVectors a and b, where b is movable and will be used for the result.

◆ operator+() [4/4]

Time sisi4s::operator+ ( Time const &  t1,
Time const &  t2 
)
inline

◆ operator-() [1/4]

template<typename F >
FockVector< F > sisi4s::operator- ( const FockVector< F > &  a,
const FockVector< F > &  b 
)
inline

Returns the difference between two FockVectors a and b, where neither a nor b are modified.

◆ operator-() [2/4]

template<typename F >
FockVector< F > && sisi4s::operator- ( const FockVector< F > &  a,
FockVector< F > &&  b 
)
inline

Returns the difference between two FockVectors a and b, where b is movable and will be used for the result.

◆ operator-() [3/4]

template<typename F >
FockVector< F > && sisi4s::operator- ( FockVector< F > &&  a,
const FockVector< F > &  b 
)
inline

Returns the difference between two FockVectors a and b, where a is movable and will be used for the result.

◆ operator-() [4/4]

Time sisi4s::operator- ( Time const &  t1,
Time const &  t2 
)
inline

◆ operator/() [1/2]

template<int N>
Permutation< N > sisi4s::operator/ ( const int  ,
const Permutation< N > &  tau 
)
inline

◆ operator/() [2/2]

template<int N>
Permutation< N > sisi4s::operator/ ( const Permutation< N > &  sigma,
const Permutation< N > &  tau 
)
inline

◆ operator<<() [1/6]

template<typename F >
std::ostream & sisi4s::operator<< ( std::ostream &  stream,
const FockVector< F > &  a 
)
inline

Writes the FockVector a to the given stream and returns it for further stream operations.

Here is the call graph for this function:

◆ operator<<() [2/6]

template<int N>
std::ostream & sisi4s::operator<< ( std::ostream &  stream,
const Map< N > &  f 
)
inline
Here is the call graph for this function:

◆ operator<<() [3/6]

std::ostream & sisi4s::operator<< ( std::ostream &  stream,
const RangeParser &  parser 
)
inline
Here is the call graph for this function:

◆ operator<<() [4/6]

template<typename F = double, int D = 3>
std::ostream & sisi4s::operator<< ( std::ostream &  stream,
sisi4s::Vector< F, D > const &  v 
)
inline
Here is the call graph for this function:

◆ operator<<() [5/6]

std::ostream & sisi4s::operator<< ( std::ostream &  stream,
SourceLocation const &  l 
)
inline
Here is the call graph for this function:

◆ operator<<() [6/6]

std::ostream & sisi4s::operator<< ( std::ostream &  stream,
Time const &  t 
)
inline
Here is the call graph for this function:

◆ permuteIndices()

template<typename A >
A sisi4s::permuteIndices ( const A &  a,
size_t  i,
size_t  j 
)
Here is the caller graph for this function:

◆ Pi()

template<typename F = double>
constexpr F sisi4s::Pi ( )
constexpr
Here is the caller graph for this function:

◆ realDot()

template<typename F = double>
F sisi4s::realDot ( F const  x,
F const  y 
)
inline

Calculates only the real part of x*conj(y).

Here is the call graph for this function:

◆ setRandom() [1/2]

template<typename Distribution , typename RandomEngine >
void sisi4s::setRandom ( complex &  value,
Distribution &  distribution,
RandomEngine &  randomEngine 
)
inline

◆ setRandom() [2/2]

template<typename Distribution , typename RandomEngine >
void sisi4s::setRandom ( double &  value,
Distribution &  distribution,
RandomEngine &  randomEngine 
)
inline
Here is the caller graph for this function:

◆ setRandomTensor()

template<typename F , typename Distribution , typename RandomEngine >
void sisi4s::setRandomTensor ( Tensor< F > &  t,
Distribution &  distribution,
RandomEngine &  randomEngine 
)
Here is the call graph for this function:
Here is the caller graph for this function:

◆ sqrt()

template<typename F = double>
F sisi4s::sqrt ( F const  x)
inline
Here is the caller graph for this function:

◆ symmetrize()

template<typename F >
void sisi4s::symmetrize ( std::string  indices,
std::string  permuted,
Tensor< F > &  t,
F  prefactor = 1 
)
inline

Apply a permutation operator and antisymmetrize accordingly, e.g. antiSymmetrize(X, "abcd", "abdc") is replaced by -1 X["abcd"] = X["abcd"] + sign(abcd -> abdc) X["abdc"].

◆ Tau()

template<typename F = double>
constexpr F sisi4s::Tau ( )
constexpr

◆ toComplexTensor() [1/3]

void sisi4s::toComplexTensor ( Tensor< double > &  r,
Tensor< complex > &  c 
)

◆ toComplexTensor() [2/3]

void sisi4s::toComplexTensor ( Tensor< double > &  r,
Tensor< double > &  c 
)

◆ toComplexTensor() [3/3]

void sisi4s::toComplexTensor ( Tensor< double > &  r,
Tensor< double > &  i,
Tensor< complex > &  c 
)

Composes a tensor of complex elements containing of the given tensors of real and imaginary parts. Note that in this overload the imaginary part may be redistributed during reading.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ toEigenMatrix()

MatrixColumnMajor sisi4s::toEigenMatrix ( Tensor< double > &  ctf)
Here is the caller graph for this function:

◆ upTr()

template<typename A >
A sisi4s::upTr ( const A &  a)
Here is the call graph for this function:
Here is the caller graph for this function:

◆ vlSym()

template<typename A >
A sisi4s::vlSym ( const A &  a)
Here is the call graph for this function:
Here is the caller graph for this function:

◆ vSym()

template<typename A >
A sisi4s::vSym ( const A &  a)
Here is the call graph for this function:
Here is the caller graph for this function: