Namespaces
namespace	CIEnvironment

namespace	EigenproblemSolver

namespace	elements

namespace	GeneralizedEigenproblemSolver

namespace	libcint

namespace	literals

namespace	Minimization

namespace	NonLinearEquation

namespace	PSEnvironment

namespace	QCMethod

namespace	QCModel

namespace	units

Classes
struct	_Unique_if

struct	_Unique_if< T[]>

struct	_Unique_if< T[N]>

class	AdjacencyMatrix

class	Algorithm

class	AngularMomentumOperator

class	AP1roGGeminalCoefficients

class	AP1roGJacobiOrbitalOptimizer

class	AP1roGLagrangianNewtonOrbitalOptimizer

class	APIGGeminalCoefficients

class	Array

class	BaseElectricalResponseSolver

class	BaseFQOperator

class	BaseHessianModifier

class	BaseMatrixPrimitiveIntegralEngine

class	BaseNuclearOperator

class	BaseOneElectronIntegralBuffer

class	BaseOneElectronIntegralEngine

class	BaseOrbitalOptimizer

class	BaseReferenceDependentOperator

class	BaseScalarFQOperator

class	BaseScalarPrimitiveIntegralEngine

class	BaseTwoElectronIntegralBuffer

class	BaseTwoElectronIntegralEngine

class	BaseVectorPrimitiveIntegralEngine

class	BasisTransformable

struct	BasisTransformableTraits

struct	BasisTransformableTraits< G1DM< Scalar > >

struct	BasisTransformableTraits< G2DM< Scalar > >

struct	BasisTransformableTraits< GSpinorBasis< _ExpansionScalar, _Shell > >

struct	BasisTransformableTraits< GSQOneElectronOperator< Scalar, Vectorizer > >

struct	BasisTransformableTraits< GSQTwoElectronOperator< Scalar, Vectorizer > >

struct	BasisTransformableTraits< GTransformation< Scalar > >

struct	BasisTransformableTraits< Orbital1DM< Scalar > >

struct	BasisTransformableTraits< Orbital2DM< Scalar > >

struct	BasisTransformableTraits< PureSpinResolved2DMComponent< Scalar > >

struct	BasisTransformableTraits< PureUSQTwoElectronOperatorComponent< Scalar, Vectorizer > >

struct	BasisTransformableTraits< RSpinOrbitalBasis< _ExpansionScalar, _Shell > >

struct	BasisTransformableTraits< RSQOneElectronOperator< Scalar, Vectorizer > >

struct	BasisTransformableTraits< RSQTwoElectronOperator< Scalar, Vectorizer > >

struct	BasisTransformableTraits< RTransformation< Scalar > >

struct	BasisTransformableTraits< ScalarGSQOneElectronOperatorProduct< Scalar > >

struct	BasisTransformableTraits< ScalarUSQOneElectronOperatorProduct< Scalar > >

struct	BasisTransformableTraits< SimpleSQTwoElectronOperator< _Scalar, _Vectorizer, _DerivedOperator > >

struct	BasisTransformableTraits< SimpleTransformation< Scalar, DerivedTransformation > >

struct	BasisTransformableTraits< SpinDensity1DM< Scalar > >

struct	BasisTransformableTraits< SpinResolved1DM< Scalar > >

struct	BasisTransformableTraits< SpinResolved1DMComponent< Scalar > >

struct	BasisTransformableTraits< SpinResolved2DM< Scalar > >

struct	BasisTransformableTraits< SQHamiltonian< ScalarSQOneElectronOperator, ScalarSQTwoElectronOperator > >

struct	BasisTransformableTraits< USpinOrbitalBasis< _ExpansionScalar, _Shell > >

struct	BasisTransformableTraits< USpinOrbitalBasisComponent< _ExpansionScalar, _Shell > >

struct	BasisTransformableTraits< USQOneElectronOperator< Scalar, Vectorizer > >

struct	BasisTransformableTraits< USQOneElectronOperatorComponent< Scalar, Vectorizer > >

struct	BasisTransformableTraits< USQTwoElectronOperator< Scalar, Vectorizer > >

struct	BasisTransformableTraits< UTransformation< Scalar > >

struct	BasisTransformableTraits< UTransformationComponent< Scalar > >

class	BoysFunction

struct	CartesianExponents

class	CartesianGTO

class	CCDAmplitudesUpdate

class	CCDEnergyCalculation

class	CCDIntermediatesUpdate

class	CCDSolver

class	CCSDAmplitudesUpdate

class	CCSDEnergyCalculation

class	CCSDEnvironment

class	CCSDIntermediatesUpdate

class	CCSDSolver

class	CompoundConvergenceCriterion

class	ConsecutiveIteratesNormConvergence

class	ConstantDamper

class	ConvergenceCriterion

class	CorrectionVectorCalculation

class	CoulombRepulsionOperator

class	CRTP

class	CubicGrid

class	CurrentDensityMatrixElement

class	CurrentDensityOperator

class	DenseDiagonalization

class	DenseVectorizer

struct	DensityMatrixTraits

struct	DensityMatrixTraits< G1DM< Scalar > >

struct	DensityMatrixTraits< G2DM< Scalar > >

struct	DensityMatrixTraits< Orbital1DM< Scalar > >

struct	DensityMatrixTraits< Orbital2DM< Scalar > >

struct	DensityMatrixTraits< PureSpinResolved2DMComponent< Scalar > >

struct	DensityMatrixTraits< SpinDensity1DM< Scalar > >

struct	DensityMatrixTraits< SpinResolved1DMComponent< Scalar > >

class	DiagonalRHFFockMatrixObjective

class	DiamagneticOperator

class	DIIS

class	DOCINewtonOrbitalOptimizer

class	DoubleLondonHermiteCoulombIntegral

class	DoublySpinResolvedBase

class	DoublySpinResolvedBasisTransformable

class	DoublySpinResolvedJacobiRotatable

class	DysonOrbital

class	Eigenpair

class	EigenproblemEnvironment

class	ElectronicDensityOperator

class	ElectronicDipoleOperator

class	ElectronicQuadrupoleOperator

class	ElectronicSpin_zOperator

class	ElectronicSpinOperator

class	ElectronicSpinSquaredOperator

class	ERJacobiLocalizer

class	ERNewtonLocalizer

class	EvaluableGSQOneElectronOperator

class	EvaluableLinearCombination

class	EvaluableRSQOneElectronOperator

class	EvaluableSimpleSQOneElectronOperator

class	EvaluableUSQOneElectronOperator

class	EvaluableUSQOneElectronOperatorComponent

class	Field

class	FQMolecularHamiltonian

class	FQMolecularMagneticHamiltonian

class	FQMolecularPauliHamiltonian

class	Function

class	FunctionalOneElectronPrimitiveIntegralEngine

class	FunctionalStep

class	FunctionalTwoElectronPrimitiveIntegralEngine

class	FunctionProduct

class	G1DM

class	G2DM

class	GeminalCoefficientsInterface

class	GeneralizedDenseDiagonalization

class	GeneralizedEigenproblemEnvironment

class	GeneralSpinorTag

class	GHFDensityMatrixCalculation

class	GHFElectronicEnergyCalculation

class	GHFErrorCalculation

class	GHFFockMatrixCalculation

class	GHFFockMatrixDiagonalization

class	GHFFockMatrixDIIS

class	GHFSCFEnvironment

class	GHFSCFSolver

class	GMullikenDomain

class	GOrbitalRotationGenerators

class	GSpinorBasis

class	GSQOneElectronOperator

class	GSQTwoElectronOperator

class	GTOBasisSet

class	GTOShell

class	GTransformation

class	GuessVectorUpdate

class	HermiteCoulombIntegral

class	HomogeneousMagneticField

class	HoppingMatrix

class	HubbardHamiltonian

class	ImplicitMatrixSlice

class	ImplicitRankFourTensorSlice

class	IntegralCalculator

class	IntegralEngine

class	IterativeAlgorithm

class	IterativeIdentitiesHessianModifier

class	JacobiOrbitalOptimizer

class	JacobiRotatable

struct	JacobiRotatableTraits

struct	JacobiRotatableTraits< G1DM< Scalar > >

struct	JacobiRotatableTraits< G2DM< Scalar > >

struct	JacobiRotatableTraits< GSpinorBasis< _ExpansionScalar, _Shell > >

struct	JacobiRotatableTraits< GSQOneElectronOperator< Scalar, Vectorizer > >

struct	JacobiRotatableTraits< GSQTwoElectronOperator< Scalar, Vectorizer > >

struct	JacobiRotatableTraits< GTransformation< Scalar > >

struct	JacobiRotatableTraits< Orbital1DM< Scalar > >

struct	JacobiRotatableTraits< Orbital2DM< Scalar > >

struct	JacobiRotatableTraits< PureSpinResolved2DMComponent< Scalar > >

struct	JacobiRotatableTraits< PureUSQTwoElectronOperatorComponent< Scalar, Vectorizer > >

struct	JacobiRotatableTraits< RSpinOrbitalBasis< _ExpansionScalar, _Shell > >

struct	JacobiRotatableTraits< RSQOneElectronOperator< Scalar, Vectorizer > >

struct	JacobiRotatableTraits< RSQTwoElectronOperator< Scalar, Vectorizer > >

struct	JacobiRotatableTraits< RTransformation< Scalar > >

struct	JacobiRotatableTraits< ScalarGSQOneElectronOperatorProduct< Scalar > >

struct	JacobiRotatableTraits< ScalarUSQOneElectronOperatorProduct< Scalar > >

struct	JacobiRotatableTraits< SimpleSQTwoElectronOperator< _Scalar, _Vectorizer, _DerivedOperator > >

struct	JacobiRotatableTraits< SimpleTransformation< Scalar, DerivedTransformation > >

struct	JacobiRotatableTraits< SpinDensity1DM< Scalar > >

struct	JacobiRotatableTraits< SpinResolved1DM< Scalar > >

struct	JacobiRotatableTraits< SpinResolved1DMComponent< Scalar > >

struct	JacobiRotatableTraits< SpinResolved2DM< Scalar > >

struct	JacobiRotatableTraits< SQHamiltonian< ScalarSQOneElectronOperator, ScalarSQTwoElectronOperator > >

struct	JacobiRotatableTraits< USpinOrbitalBasis< _ExpansionScalar, _Shell > >

struct	JacobiRotatableTraits< USpinOrbitalBasisComponent< _ExpansionScalar, _Shell > >

struct	JacobiRotatableTraits< USQOneElectronOperator< Scalar, Vectorizer > >

struct	JacobiRotatableTraits< USQOneElectronOperatorComponent< Scalar, Vectorizer > >

struct	JacobiRotatableTraits< USQTwoElectronOperator< Scalar, Vectorizer > >

struct	JacobiRotatableTraits< UTransformation< Scalar > >

struct	JacobiRotatableTraits< UTransformationComponent< Scalar > >

class	JacobiRotation

class	KineticOperator

class	LeviCivitaTensor

class	LibcintInterfacer

class	LibcintOneElectronIntegralBuffer

class	LibcintOneElectronIntegralEngine

class	LibcintTwoElectronIntegralBuffer

class	LibcintTwoElectronIntegralEngine

class	LibintInterfacer

class	LibintOneElectronIntegralBuffer

class	LibintOneElectronIntegralEngine

class	LibintTwoElectronIntegralBuffer

class	LibintTwoElectronIntegralEngine

class	LinearExpansion

class	LinearMomentumOperator

class	LondonCartesianGTO

class	LondonGTOShell

class	LondonHermiteCoulombIntegral

class	Matrix

class	MatrixRepresentationEvaluationContainer

class	MatrixRepresentationEvaluationContainer< Eigen::SparseMatrix< _Scalar > >

class	MatrixRepresentationEvaluationContainer< VectorX< _Scalar > >

class	MatrixVectorProductCalculation

class	McMurchieDavidsonCoefficient

class	MinimizationEnvironment

class	Minimizer

class	MixedSpinResolved2DMComponent

class	MixedUSQTwoElectronOperatorComponent

class	Molecule

class	NewtonOrbitalOptimizer

class	NonLinearEquationEnvironment

class	NonLinearEquationSolver

class	NuclearAttractionOperator

class	NuclearDipoleOperator

class	NuclearFramework

class	NuclearRepulsionOperator

class	Nucleus

class	OneElectronIntegralBuffer

class	OneElectronIntegralEngine

struct	OperatorTraits

struct	OperatorTraits< EvaluableGSQOneElectronOperator< _FunctionType, _Vectorizer > >

struct	OperatorTraits< EvaluableRSQOneElectronOperator< _FunctionType, _Vectorizer > >

struct	OperatorTraits< EvaluableSimpleSQOneElectronOperator< _FunctionType, _Vectorizer, _DerivedEvaluableOperator > >

struct	OperatorTraits< EvaluableUSQOneElectronOperator< _FunctionType, _Vectorizer > >

struct	OperatorTraits< EvaluableUSQOneElectronOperatorComponent< _FunctionType, _Vectorizer > >

struct	OperatorTraits< GSQOneElectronOperator< Scalar, Vectorizer > >

struct	OperatorTraits< GSQTwoElectronOperator< Scalar, Vectorizer > >

struct	OperatorTraits< MixedUSQTwoElectronOperatorComponent< _Scalar, _Vectorizer > >

struct	OperatorTraits< PureUSQTwoElectronOperatorComponent< Scalar, Vectorizer > >

struct	OperatorTraits< RSQOneElectronOperator< Scalar, Vectorizer > >

struct	OperatorTraits< RSQTwoElectronOperator< Scalar, Vectorizer > >

struct	OperatorTraits< SimpleSQOneElectronOperator< _Scalar, _Vectorizer, _DerivedOperator > >

struct	OperatorTraits< SimpleSQTwoElectronOperator< _Scalar, _Vectorizer, _DerivedOperator > >

struct	OperatorTraits< SQHamiltonian< ScalarSQOneElectronOperator, ScalarSQTwoElectronOperator > >

struct	OperatorTraits< USQOneElectronOperator< Scalar, Vectorizer > >

struct	OperatorTraits< USQOneElectronOperatorComponent< Scalar, Vectorizer > >

struct	OperatorTraits< USQTwoElectronOperator< Scalar, Vectorizer > >

class	OptimizationEnvironment

class	Orbital1DM

class	Orbital2DM

struct	OrbitalRotationGeneratorTraits

struct	OrbitalRotationGeneratorTraits< GTransformation< Scalar > >

struct	OrbitalRotationGeneratorTraits< RTransformation< Scalar > >

struct	OrbitalRotationGeneratorTraits< UTransformation< Scalar > >

struct	OrbitalRotationGeneratorTraits< UTransformationComponent< Scalar > >

class	OrbitalSpace

class	OrbitalZeemanOperator

class	OverlapOperator

class	PrimitiveAngularMomentumIntegralEngine

class	PrimitiveCanonicalKineticEnergyIntegralEngine

class	PrimitiveCoulombRepulsionIntegralEngine

class	PrimitiveElectronicDipoleIntegralEngine

class	PrimitiveElectronicQuadrupoleIntegralEngine

class	PrimitiveLinearMomentumIntegralEngine

class	PrimitiveNuclearAttractionIntegralEngine

class	PrimitiveOverlapIntegralEngine

class	PureSpinResolved2DMComponent

class	PureUSQTwoElectronOperatorComponent

class	QCMethodNewtonOrbitalOptimizer

class	QCStructure

class	ResidualVectorCalculation

class	ResidualVectorConvergence

class	RestrictedSpinorTag

class	RHFDensityMatrixCalculation

class	RHFDensityMatrixDamper

class	RHFElectricalResponseSolver

class	RHFElectronicEnergyCalculation

class	RHFErrorCalculation

class	RHFFockMatrixCalculation

class	RHFFockMatrixDiagonalization

class	RHFFockMatrixDIIS

class	RHFSCFEnvironment

class	RHFSCFSolver

class	RMullikenDomain

class	ROrbitalRotationGenerators

class	RSpinOrbitalBasis

class	RSQOneElectronOperator

class	RSQTwoElectronOperator

class	RTransformation

class	ScalarBasis

class	ScalarGSQOneElectronOperatorProduct

class	ScalarUSQOneElectronOperatorProduct

class	ShellSet

class	Simple1DM

class	Simple2DM

class	SimpleOrbitalRotationGenerators

class	SimpleSpinorBasis

class	SimpleSpinOrbitalBasis

class	SimpleSQOneElectronOperator

class	SimpleSQTwoElectronOperator

class	SimpleTransformation

class	SpinDensity1DM

class	Spinor

struct	SpinorBasisTraits

struct	SpinorBasisTraits< GSpinorBasis< _ExpansionScalar, _Shell > >

struct	SpinorBasisTraits< RSpinOrbitalBasis< _ExpansionScalar, _Shell > >

struct	SpinorBasisTraits< USpinOrbitalBasisComponent< ExpansionScalar, Shell > >

class	SpinResolved

class	SpinResolved1DM

class	SpinResolved1DMComponent

class	SpinResolved2DM

class	SpinResolvedBase

class	SpinResolvedBasisTransformable

class	SpinResolvedJacobiRotatable

class	SpinResolvedOrbitalSpace

class	SpinZeemanOperator

class	SQHamiltonian

class	SQOperatorStorage

class	SQOperatorStorageBase

class	SquareMatrix

class	SquareRankFourTensor

class	Step

class	StepCollection

class	StorageArray

class	SubspaceMatrixCalculation

class	SubspaceMatrixDiagonalization

class	SubspaceUpdate

class	T1Amplitudes

class	T2Amplitudes

class	T2DIIS

class	T2ErrorCalculation

class	Tensor

class	TwoElectronIntegralBuffer

class	TwoElectronIntegralEngine

class	UHFDensityMatrixCalculation

class	UHFElectronicEnergyCalculation

class	UHFErrorCalculation

class	UHFFockMatrixCalculation

class	UHFFockMatrixDiagonalization

class	UHFFockMatrixDIIS

class	UHFSCFEnvironment

class	UHFSCFSolver

class	UJacobiRotation

class	UMullikenDomain

class	UMullikenDomainComponent

class	UnalteringHessianModifier

class	UnrestrictedSpinorTag

class	UOrbitalRotationGenerators

class	UOrbitalRotationGeneratorsComponent

class	USpinOrbitalBasis

class	USpinOrbitalBasisComponent

class	USQOneElectronOperator

class	USQOneElectronOperatorComponent

class	USQTwoElectronOperator

class	UTransformation

class	UTransformationComponent

class	vAP1roGElectricalResponseSolver

class	VectorSpaceArithmetic

class	WeightedGrid

Typedefs
using	Libcint1eFunction = std::function< int(double , const int , const int , int, const int , int, const double *)>

using	Libcint2eFunction = std::function< int(double , const int , const int , int, const int , int, const double , const CINTOpt )>

using	Libcint2eOptimizerFunction = std::function< void(CINTOpt *, const int , int, const int , int, const double )>

template<typename ExpansionScalar , typename Shell >
using	RSpinorBasis = RSpinOrbitalBasis< ExpansionScalar, Shell >

template<typename ExpansionScalar , typename Shell >
using	USpinorBasis = USpinOrbitalBasis< ExpansionScalar, Shell >

template<typename T >
using	IsFunction = enable_if_t< std::is_base_of< Function< typename T::OutputType, typename T::InputType >, T >::value >

template<typename Scalar >
using	VectorField = Field< Vector< Scalar, 3 > >

template<typename Scalar >
using	MatrixField = Field< Matrix< Scalar, 3, 3 > >

template<typename Scalar >
using	ArrayX = Array< Scalar, Dynamic, 1 >

template<typename Scalar >
using	ArrayXX = Array< Scalar, Dynamic, Dynamic >

using	ScalarVectorizer = DenseVectorizer< 0 >

using	VectorVectorizer = DenseVectorizer< 1 >

using	MatrixVectorizer = DenseVectorizer< 2 >

template<size_t A>
using	TensorVectorizer = DenseVectorizer< A >

template<typename Scalar , int Rows>
using	Vector = Matrix< Scalar, Rows, 1 >

template<typename Scalar >
using	MatrixX = Matrix< Scalar, Dynamic, Dynamic >

template<typename Scalar >
using	VectorX = Vector< Scalar, Dynamic >

template<typename Scalar >
using	VectorFunction = std::function< VectorX< Scalar >(const VectorX< Scalar > &)>

template<typename Scalar >
using	MatrixFunction = std::function< MatrixX< Scalar >(const VectorX< Scalar > &)>

template<typename Scalar >
using	BaseScalarFQOneElectronOperator = BaseScalarFQOperator< 1, Scalar >

template<typename Scalar >
using	BaseVectorFQOneElectronOperator = BaseFQOperator< 1, Scalar, VectorVectorizer >

template<typename Scalar >
using	BaseMatrixFQOneElectronOperator = BaseFQOperator< 1, Scalar, MatrixVectorizer >

template<typename Scalar , size_t N>
using	BaseTensorFQOneElectronOperator = BaseFQOperator< 1, Scalar, TensorVectorizer< N > >

template<typename Scalar >
using	BaseScalarFQTwoElectronOperator = BaseScalarFQOperator< 2, Scalar >

template<typename Scalar >
using	BaseVectorFQTwoElectronOperator = BaseFQOperator< 2, Scalar, VectorVectorizer >

template<typename Scalar >
using	BaseMatrixFQTwoElectronOperator = BaseFQOperator< 2, Scalar, MatrixVectorizer >

template<typename Scalar , size_t N>
using	BaseTensorFQTwoElectronOperator = BaseFQOperator< 2, Scalar, TensorVectorizer< N > >

template<typename FunctionType >
using	ScalarEvaluableGSQOneElectronOperator = EvaluableGSQOneElectronOperator< FunctionType, ScalarVectorizer >

template<typename FunctionType >
using	VectorEvaluableGSQOneElectronOperator = EvaluableGSQOneElectronOperator< FunctionType, VectorVectorizer >

template<typename FunctionType >
using	MatrixEvaluableGSQOneElectronOperator = EvaluableGSQOneElectronOperator< FunctionType, MatrixVectorizer >

template<typename FunctionType , size_t N>
using	TensorEvaluableGSQOneElectronOperator = EvaluableGSQOneElectronOperator< FunctionType, TensorVectorizer< N > >

template<typename FunctionType >
using	ScalarEvaluableRSQOneElectronOperator = EvaluableRSQOneElectronOperator< FunctionType, ScalarVectorizer >

template<typename FunctionType >
using	VectorEvaluableRSQOneElectronOperator = EvaluableRSQOneElectronOperator< FunctionType, VectorVectorizer >

template<typename FunctionType >
using	MatrixEvaluableRSQOneElectronOperator = EvaluableRSQOneElectronOperator< FunctionType, MatrixVectorizer >

template<typename FunctionType , size_t N>
using	TensorEvaluableRSQOneElectronOperator = EvaluableRSQOneElectronOperator< FunctionType, TensorVectorizer< N > >

template<typename FunctionType >
using	ScalarEvaluableUSQOneElectronOperator = EvaluableUSQOneElectronOperator< FunctionType, ScalarVectorizer >

template<typename FunctionType >
using	VectorEvaluableUSQOneElectronOperator = EvaluableUSQOneElectronOperator< FunctionType, VectorVectorizer >

template<typename FunctionType >
using	MatrixEvaluableUSQOneElectronOperator = EvaluableUSQOneElectronOperator< FunctionType, MatrixVectorizer >

template<typename FunctionType , size_t N>
using	TensorEvaluableUSQOneElectronOperator = EvaluableUSQOneElectronOperator< FunctionType, TensorVectorizer< N > >

template<typename FunctionType >
using	ScalarEvaluableUSQOneElectronOperatorComponent = EvaluableUSQOneElectronOperatorComponent< FunctionType, ScalarVectorizer >

template<typename FunctionType >
using	VectorEvaluableUSQOneElectronOperatorComponent = EvaluableUSQOneElectronOperatorComponent< FunctionType, VectorVectorizer >

template<typename FunctionType >
using	MatrixEvaluableUSQOneElectronOperatorComponent = EvaluableUSQOneElectronOperatorComponent< FunctionType, MatrixVectorizer >

template<typename FunctionType , size_t N>
using	TensorEvaluableUSQOneElectronOperatorComponent = EvaluableUSQOneElectronOperatorComponent< FunctionType, TensorVectorizer< N > >

template<typename Scalar >
using	ScalarGSQOneElectronOperator = GSQOneElectronOperator< Scalar, ScalarVectorizer >

template<typename Scalar >
using	VectorGSQOneElectronOperator = GSQOneElectronOperator< Scalar, VectorVectorizer >

template<typename Scalar >
using	MatrixGSQOneElectronOperator = GSQOneElectronOperator< Scalar, MatrixVectorizer >

template<typename Scalar , size_t N>
using	TensorGSQOneElectronOperator = GSQOneElectronOperator< Scalar, TensorVectorizer< N > >

template<typename Scalar >
using	ScalarGSQTwoElectronOperator = GSQTwoElectronOperator< Scalar, ScalarVectorizer >

template<typename Scalar >
using	VectorGSQTwoElectronOperator = GSQTwoElectronOperator< Scalar, VectorVectorizer >

template<typename Scalar >
using	MatrixGSQTwoElectronOperator = GSQTwoElectronOperator< Scalar, MatrixVectorizer >

template<typename Scalar , size_t N>
using	TensorGSQTwoElectronOperator = GSQTwoElectronOperator< Scalar, TensorVectorizer< N > >

template<typename Scalar >
using	ScalarMixedUSQTwoElectronOperatorComponent = MixedUSQTwoElectronOperatorComponent< Scalar, ScalarVectorizer >

template<typename Scalar >
using	VectorMixedUSQTwoElectronOperatorComponent = MixedUSQTwoElectronOperatorComponent< Scalar, VectorVectorizer >

template<typename Scalar >
using	MatrixMixedUSQTwoElectronOperatorComponent = MixedUSQTwoElectronOperatorComponent< Scalar, MatrixVectorizer >

template<typename Scalar , size_t N>
using	TensorMixedUSQTwoElectronOperatorComponent = MixedUSQTwoElectronOperatorComponent< Scalar, TensorVectorizer< N > >

template<typename Scalar >
using	ScalarPureUSQTwoElectronOperatorComponent = PureUSQTwoElectronOperatorComponent< Scalar, ScalarVectorizer >

template<typename Scalar >
using	VectorPureUSQTwoElectronOperatorComponent = PureUSQTwoElectronOperatorComponent< Scalar, VectorVectorizer >

template<typename Scalar >
using	MatrixPureUSQTwoElectronOperatorComponent = PureUSQTwoElectronOperatorComponent< Scalar, MatrixVectorizer >

template<typename Scalar , size_t N>
using	TensorPureUSQTwoElectronOperatorComponent = PureUSQTwoElectronOperatorComponent< Scalar, TensorVectorizer< N > >

template<typename Scalar >
using	ScalarRSQOneElectronOperator = RSQOneElectronOperator< Scalar, ScalarVectorizer >

template<typename Scalar >
using	VectorRSQOneElectronOperator = RSQOneElectronOperator< Scalar, VectorVectorizer >

template<typename Scalar >
using	MatrixRSQOneElectronOperator = RSQOneElectronOperator< Scalar, MatrixVectorizer >

template<typename Scalar , size_t N>
using	TensorRSQOneElectronOperator = RSQOneElectronOperator< Scalar, TensorVectorizer< N > >

template<typename Scalar >
using	ScalarRSQTwoElectronOperator = RSQTwoElectronOperator< Scalar, ScalarVectorizer >

template<typename Scalar >
using	VectorRSQTwoElectronOperator = RSQTwoElectronOperator< Scalar, VectorVectorizer >

template<typename Scalar >
using	MatrixRSQTwoElectronOperator = RSQTwoElectronOperator< Scalar, MatrixVectorizer >

template<typename Scalar , size_t N>
using	TensorRSQTwoElectronOperator = RSQTwoElectronOperator< Scalar, TensorVectorizer< N > >

template<typename Scalar >
using	RSQHamiltonian = SQHamiltonian< ScalarRSQOneElectronOperator< Scalar >, ScalarRSQTwoElectronOperator< Scalar > >

template<typename Scalar >
using	USQHamiltonian = SQHamiltonian< ScalarUSQOneElectronOperator< Scalar >, ScalarUSQTwoElectronOperator< Scalar > >

template<typename Scalar >
using	GSQHamiltonian = SQHamiltonian< ScalarGSQOneElectronOperator< Scalar >, ScalarGSQTwoElectronOperator< Scalar > >

template<typename Scalar >
using	ScalarUSQOneElectronOperator = USQOneElectronOperator< Scalar, ScalarVectorizer >

template<typename Scalar >
using	VectorUSQOneElectronOperator = USQOneElectronOperator< Scalar, VectorVectorizer >

template<typename Scalar >
using	MatrixUSQOneElectronOperator = USQOneElectronOperator< Scalar, MatrixVectorizer >

template<typename Scalar , size_t N>
using	TensorUSQOneElectronOperator = USQOneElectronOperator< Scalar, TensorVectorizer< N > >

template<typename Scalar >
using	ScalarUSQOneElectronOperatorComponent = USQOneElectronOperatorComponent< Scalar, ScalarVectorizer >

template<typename Scalar >
using	VectorUSQOneElectronOperatorComponent = USQOneElectronOperatorComponent< Scalar, VectorVectorizer >

template<typename Scalar >
using	MatrixUSQOneElectronOperatorComponent = USQOneElectronOperatorComponent< Scalar, MatrixVectorizer >

template<typename Scalar , size_t N>
using	TensorUSQOneElectronOperatorComponent = USQOneElectronOperatorComponent< Scalar, TensorVectorizer< N > >

template<typename Scalar >
using	ScalarUSQTwoElectronOperator = USQTwoElectronOperator< Scalar, ScalarVectorizer >

template<typename Scalar >
using	VectorUSQTwoElectronOperator = USQTwoElectronOperator< Scalar, VectorVectorizer >

template<typename Scalar >
using	MatrixUSQTwoElectronOperator = USQTwoElectronOperator< Scalar, MatrixVectorizer >

template<typename Scalar , size_t N>
using	TensorUSQTwoElectronOperator = USQTwoElectronOperator< Scalar, TensorVectorizer< N > >

using	RestrictedSpinOrbitalTag = RestrictedSpinorTag

using	UnrestrictedSpinOrbitalTag = UnrestrictedSpinorTag

template<typename T , typename U >
using	product_t = decltype(std::declval< T >() *std::declval< U >())

template<typename T , typename U >
using	sum_t = decltype(std::declval< T >()+std::declval< U >())

using	complex = std::complex< double >

template<typename T >
using	IsReal = enable_if_t< std::is_same< T, double >::value >

template<typename T >
using	IsComplex = enable_if_t< std::is_same< T, complex >::value >

template<bool B, typename T = void>
using	enable_if_t = typename std::enable_if< B, T >::type

Enumerations
enum class	OccupationType { k_occupied , k_active , k_virtual }

enum	CartesianDirection { x = 0 , y = 1 , z = 2 }

enum	DyadicCartesianDirection { xx = 0 , xy = 1 , xz = 2 , yx = 3 , yy = 4 , yz = 5 , zx = 6 , zy = 7 , zz = 8 }

enum class	Ordering { ColumnMajor , RowMajor }

enum	Spin { alpha = 0 , beta = 1 }

Functions
FINT	cint2e_cart_const (double buf, const int shls, const int atm, int natm, const int bas, int nbas, const double env, const CINTOpt opt)

void	cint2e_cart_optimizer_const (CINTOpt *opt, const int atm, int natm, const int bas, int nbas, const double env)

template<typename TransformationType , typename TransformableType >
void	transform (const TransformationType &T, TransformableType &transformable)

template<typename TransformationType , typename First , typename... Others>
void	transform (const TransformationType &T, First &first, Others &... others)

template<typename RotationType , typename RotatableType >
void	rotate (const RotationType &U, RotatableType &rotatable)

template<typename RotationType , typename First , typename... Others>
void	rotate (const RotationType &U, First &first, Others &... others)

template<typename F1 , typename F2 , typename = IsFunction<F1>, typename = IsFunction<F2>>
FunctionProduct< F1, F2 >	operator* (const F1 &lhs, const F2 &rhs)

VectorX< double >	newtonStep (const VectorX< double > &x, const VectorFunction< double > &f, const MatrixFunction< double > &J)

template<typename Scalar >
ScalarGSQOneElectronOperatorProduct< Scalar >	operator* (const ScalarGSQOneElectronOperator< Scalar > &lhs, const ScalarGSQOneElectronOperator< Scalar > &rhs)

template<typename Scalar >
double	calculateSpinSquared (const SpinResolved1DM< Scalar > &one_DMs, const SpinResolved2DM< Scalar > &two_DMs)

template<typename Scalar >
double	calculateSpinZ (const SpinResolved1DM< Scalar > &one_DMs)

Matrix< double, 3, 3 >	calculateElectricPolarizability (const Matrix< double, Dynamic, 3 > &F_p, const Matrix< double, Dynamic, 3 > &response)

Matrix< double, 3, 3 >	calculateElectricPolarizability (const Matrix< double, Dynamic, 3 > &F_p, const Matrix< double, Dynamic, 3 > &x, const Matrix< double, Dynamic, 3 > &A_lambda, const Matrix< double, Dynamic, 3 > &y)

double	calculateRMP2EnergyCorrection (const RSQHamiltonian< double > &sq_hamiltonian, const QCModel::RHF< double > &rhf_parameters)

complex	conj (const complex &c)

double	conj (const double d)

template<class T , class... Args>
_Unique_if< T >::_Single_object	make_unique (Args &&... args)

template<class T >
_Unique_if< T >::_Unknown_bound	make_unique (size_t n)

template<class T , class... Args>
_Unique_if< T >::_Known_bound	make_unique (Args &&...)=delete

template<typename T >
size_t	findElementIndex (const std::vector< T > &vector, const T &value)

std::vector< std::vector< size_t > >	generatePartitionsOf (const size_t n, const size_t k)

std::vector< std::vector< size_t > >	generateUniquePartitionsOf (const size_t n, const size_t k)

size_t	grayCodeOf (const size_t S)

size_t	matrixIndexMajor (const size_t v, const size_t cols, const size_t skipped=0)

size_t	matrixIndexMinor (const size_t v, const size_t cols, const size_t skipped=0)

void	printExecutionTime (const std::string &method_name, const std::function< void()> &function)

size_t	strictTriangularRootOf (const size_t x)

size_t	triangularRootOf (const size_t x)

std::ifstream	validateAndOpen (const std::string &filename, const std::string &extension)

size_t	vectorIndex (const size_t i, const size_t j, const size_t cols, size_t skipped=0)

std::ostream &	operator<< (std::ostream &os, const JacobiRotation &jacobi_rotation)

std::ostream &	operator<< (std::ostream &os, const Molecule &molecule)

std::ostream &	operator<< (std::ostream &os, const NuclearFramework &nuclear_framework)

std::ostream &	operator<< (std::ostream &os, const Nucleus &nucleus)

std::ostream &	operator<< (std::ostream &os, const SpinUnresolvedONV &onv)

Variables
constexpr auto	Dynamic = Eigen::Dynamic

Detailed Description

An extension of the Eigen::Array class, with extra operations

Template Parameters

_Scalar	the scalar representation type
_Rows	the number of rows (int or Dynamic)
_Cols	the number of columns (int or Dynamic)

A header that contains general aliases inside the GQCP namespace.

Extensions of the <memory> header that haven't been included in C++11 A C++11 implementation for std::make_unique. Taken from https://stackoverflow.com/a/17902439.

Extensions of the <type_traits> header that haven't been included in C++11 An implementation of enable_if_t.

Typedef Documentation

◆ ArrayX

template<typename Scalar >

using GQCP::ArrayX = typedef Array<Scalar, Dynamic, 1>

◆ ArrayXX

template<typename Scalar >

using GQCP::ArrayXX = typedef Array<Scalar, Dynamic, Dynamic>

◆ BaseMatrixFQOneElectronOperator

template<typename Scalar >

using GQCP::BaseMatrixFQOneElectronOperator = typedef BaseFQOperator<1, Scalar, MatrixVectorizer>

◆ BaseMatrixFQTwoElectronOperator

template<typename Scalar >

using GQCP::BaseMatrixFQTwoElectronOperator = typedef BaseFQOperator<2, Scalar, MatrixVectorizer>

◆ BaseScalarFQOneElectronOperator

template<typename Scalar >

using GQCP::BaseScalarFQOneElectronOperator = typedef BaseScalarFQOperator<1, Scalar>

◆ BaseScalarFQTwoElectronOperator

template<typename Scalar >

using GQCP::BaseScalarFQTwoElectronOperator = typedef BaseScalarFQOperator<2, Scalar>

◆ BaseTensorFQOneElectronOperator

template<typename Scalar , size_t N>

using GQCP::BaseTensorFQOneElectronOperator = typedef BaseFQOperator<1, Scalar, TensorVectorizer<N> >

◆ BaseTensorFQTwoElectronOperator

template<typename Scalar , size_t N>

using GQCP::BaseTensorFQTwoElectronOperator = typedef BaseFQOperator<2, Scalar, TensorVectorizer<N> >

◆ BaseVectorFQOneElectronOperator

template<typename Scalar >

using GQCP::BaseVectorFQOneElectronOperator = typedef BaseFQOperator<1, Scalar, VectorVectorizer>

◆ BaseVectorFQTwoElectronOperator

template<typename Scalar >

using GQCP::BaseVectorFQTwoElectronOperator = typedef BaseFQOperator<2, Scalar, VectorVectorizer>

◆ complex

using GQCP::complex = typedef std::complex<double>

An alias for a complex<double>.

◆ enable_if_t

template<bool B, typename T = void>

using GQCP::enable_if_t = typedef typename std::enable_if<B, T>::type

◆ GSQHamiltonian

template<typename Scalar >

using GQCP::GSQHamiltonian = typedef SQHamiltonian<ScalarGSQOneElectronOperator<Scalar>, ScalarGSQTwoElectronOperator<Scalar> >

◆ IsComplex

template<typename T >

using GQCP::IsComplex = typedef enable_if_t<std::is_same<T, complex>::value>

◆ IsFunction

template<typename T >

using GQCP::IsFunction = typedef enable_if_t<std::is_base_of<Function<typename T::OutputType, typename T::InputType>, T>::value>

A SFINAE expression that checks if the type T derives from Function.

◆ IsReal

template<typename T >

using GQCP::IsReal = typedef enable_if_t<std::is_same<T, double>::value>

◆ Libcint1eFunction

using GQCP::Libcint1eFunction = typedef std::function<int(double*, const int*, const int*, int, const int*, int, const double*)>

◆ Libcint2eFunction

using GQCP::Libcint2eFunction = typedef std::function<int(double*, const int*, const int*, int, const int*, int, const double*, const CINTOpt*)>

◆ Libcint2eOptimizerFunction

using GQCP::Libcint2eOptimizerFunction = typedef std::function<void(CINTOpt**, const int*, int, const int*, int, const double*)>

◆ MatrixEvaluableGSQOneElectronOperator

template<typename FunctionType >

using GQCP::MatrixEvaluableGSQOneElectronOperator = typedef EvaluableGSQOneElectronOperator<FunctionType, MatrixVectorizer>

◆ MatrixEvaluableRSQOneElectronOperator

template<typename FunctionType >

using GQCP::MatrixEvaluableRSQOneElectronOperator = typedef EvaluableRSQOneElectronOperator<FunctionType, MatrixVectorizer>

◆ MatrixEvaluableUSQOneElectronOperator

template<typename FunctionType >

using GQCP::MatrixEvaluableUSQOneElectronOperator = typedef EvaluableUSQOneElectronOperator<FunctionType, MatrixVectorizer>

◆ MatrixEvaluableUSQOneElectronOperatorComponent

template<typename FunctionType >

using GQCP::MatrixEvaluableUSQOneElectronOperatorComponent = typedef EvaluableUSQOneElectronOperatorComponent<FunctionType, MatrixVectorizer>

◆ MatrixField

template<typename Scalar >

using GQCP::MatrixField = typedef Field<Matrix<Scalar, 3, 3> >

◆ MatrixFunction

template<typename Scalar >

using GQCP::MatrixFunction = typedef std::function<MatrixX<Scalar>(const VectorX<Scalar>&)>

◆ MatrixGSQOneElectronOperator

template<typename Scalar >

using GQCP::MatrixGSQOneElectronOperator = typedef GSQOneElectronOperator<Scalar, MatrixVectorizer>

◆ MatrixGSQTwoElectronOperator

template<typename Scalar >

using GQCP::MatrixGSQTwoElectronOperator = typedef GSQTwoElectronOperator<Scalar, MatrixVectorizer>

◆ MatrixMixedUSQTwoElectronOperatorComponent

template<typename Scalar >

using GQCP::MatrixMixedUSQTwoElectronOperatorComponent = typedef MixedUSQTwoElectronOperatorComponent<Scalar, MatrixVectorizer>

◆ MatrixPureUSQTwoElectronOperatorComponent

template<typename Scalar >

using GQCP::MatrixPureUSQTwoElectronOperatorComponent = typedef PureUSQTwoElectronOperatorComponent<Scalar, MatrixVectorizer>

◆ MatrixRSQOneElectronOperator

template<typename Scalar >

using GQCP::MatrixRSQOneElectronOperator = typedef RSQOneElectronOperator<Scalar, MatrixVectorizer>

◆ MatrixRSQTwoElectronOperator

template<typename Scalar >

using GQCP::MatrixRSQTwoElectronOperator = typedef RSQTwoElectronOperator<Scalar, MatrixVectorizer>

◆ MatrixUSQOneElectronOperator

template<typename Scalar >

using GQCP::MatrixUSQOneElectronOperator = typedef USQOneElectronOperator<Scalar, MatrixVectorizer>

◆ MatrixUSQOneElectronOperatorComponent

template<typename Scalar >

using GQCP::MatrixUSQOneElectronOperatorComponent = typedef USQOneElectronOperatorComponent<Scalar, MatrixVectorizer>

◆ MatrixUSQTwoElectronOperator

template<typename Scalar >

using GQCP::MatrixUSQTwoElectronOperator = typedef USQTwoElectronOperator<Scalar, MatrixVectorizer>

◆ MatrixVectorizer

using GQCP::MatrixVectorizer = typedef DenseVectorizer<2>

◆ MatrixX

template<typename Scalar >

using GQCP::MatrixX = typedef Matrix<Scalar, Dynamic, Dynamic>

◆ product_t

template<typename T , typename U >

using GQCP::product_t = typedef decltype(std::declval<T>() * std::declval<U>())

◆ RestrictedSpinOrbitalTag

using GQCP::RestrictedSpinOrbitalTag = typedef RestrictedSpinorTag

A tag designating types corresponding to spin-orbitals whose spatial parts are equal.

◆ RSpinorBasis

template<typename ExpansionScalar , typename Shell >

using GQCP::RSpinorBasis = typedef RSpinOrbitalBasis<ExpansionScalar, Shell>

◆ RSQHamiltonian

template<typename Scalar >

using GQCP::RSQHamiltonian = typedef SQHamiltonian<ScalarRSQOneElectronOperator<Scalar>, ScalarRSQTwoElectronOperator<Scalar> >

◆ ScalarEvaluableGSQOneElectronOperator

template<typename FunctionType >

using GQCP::ScalarEvaluableGSQOneElectronOperator = typedef EvaluableGSQOneElectronOperator<FunctionType, ScalarVectorizer>

◆ ScalarEvaluableRSQOneElectronOperator

template<typename FunctionType >

using GQCP::ScalarEvaluableRSQOneElectronOperator = typedef EvaluableRSQOneElectronOperator<FunctionType, ScalarVectorizer>

◆ ScalarEvaluableUSQOneElectronOperator

template<typename FunctionType >

using GQCP::ScalarEvaluableUSQOneElectronOperator = typedef EvaluableUSQOneElectronOperator<FunctionType, ScalarVectorizer>

◆ ScalarEvaluableUSQOneElectronOperatorComponent

template<typename FunctionType >

using GQCP::ScalarEvaluableUSQOneElectronOperatorComponent = typedef EvaluableUSQOneElectronOperatorComponent<FunctionType, ScalarVectorizer>

◆ ScalarGSQOneElectronOperator

template<typename Scalar >

using GQCP::ScalarGSQOneElectronOperator = typedef GSQOneElectronOperator<Scalar, ScalarVectorizer>

◆ ScalarGSQTwoElectronOperator

template<typename Scalar >

using GQCP::ScalarGSQTwoElectronOperator = typedef GSQTwoElectronOperator<Scalar, ScalarVectorizer>

◆ ScalarMixedUSQTwoElectronOperatorComponent

template<typename Scalar >

using GQCP::ScalarMixedUSQTwoElectronOperatorComponent = typedef MixedUSQTwoElectronOperatorComponent<Scalar, ScalarVectorizer>

◆ ScalarPureUSQTwoElectronOperatorComponent

template<typename Scalar >

using GQCP::ScalarPureUSQTwoElectronOperatorComponent = typedef PureUSQTwoElectronOperatorComponent<Scalar, ScalarVectorizer>

◆ ScalarRSQOneElectronOperator

template<typename Scalar >

using GQCP::ScalarRSQOneElectronOperator = typedef RSQOneElectronOperator<Scalar, ScalarVectorizer>

◆ ScalarRSQTwoElectronOperator

template<typename Scalar >

using GQCP::ScalarRSQTwoElectronOperator = typedef RSQTwoElectronOperator<Scalar, ScalarVectorizer>

◆ ScalarUSQOneElectronOperator

template<typename Scalar >

using GQCP::ScalarUSQOneElectronOperator = typedef USQOneElectronOperator<Scalar, ScalarVectorizer>

◆ ScalarUSQOneElectronOperatorComponent

template<typename Scalar >

using GQCP::ScalarUSQOneElectronOperatorComponent = typedef USQOneElectronOperatorComponent<Scalar, ScalarVectorizer>

◆ ScalarUSQTwoElectronOperator

template<typename Scalar >

using GQCP::ScalarUSQTwoElectronOperator = typedef USQTwoElectronOperator<Scalar, ScalarVectorizer>

◆ ScalarVectorizer

using GQCP::ScalarVectorizer = typedef DenseVectorizer<0>

◆ sum_t

template<typename T , typename U >

using GQCP::sum_t = typedef decltype(std::declval<T>() + std::declval<U>())

◆ TensorEvaluableGSQOneElectronOperator

template<typename FunctionType , size_t N>

using GQCP::TensorEvaluableGSQOneElectronOperator = typedef EvaluableGSQOneElectronOperator<FunctionType, TensorVectorizer<N> >

◆ TensorEvaluableRSQOneElectronOperator

template<typename FunctionType , size_t N>

using GQCP::TensorEvaluableRSQOneElectronOperator = typedef EvaluableRSQOneElectronOperator<FunctionType, TensorVectorizer<N> >

◆ TensorEvaluableUSQOneElectronOperator

template<typename FunctionType , size_t N>

using GQCP::TensorEvaluableUSQOneElectronOperator = typedef EvaluableUSQOneElectronOperator<FunctionType, TensorVectorizer<N> >

◆ TensorEvaluableUSQOneElectronOperatorComponent

template<typename FunctionType , size_t N>

using GQCP::TensorEvaluableUSQOneElectronOperatorComponent = typedef EvaluableUSQOneElectronOperatorComponent<FunctionType, TensorVectorizer<N> >

◆ TensorGSQOneElectronOperator

template<typename Scalar , size_t N>

using GQCP::TensorGSQOneElectronOperator = typedef GSQOneElectronOperator<Scalar, TensorVectorizer<N> >

◆ TensorGSQTwoElectronOperator

template<typename Scalar , size_t N>

using GQCP::TensorGSQTwoElectronOperator = typedef GSQTwoElectronOperator<Scalar, TensorVectorizer<N> >

◆ TensorMixedUSQTwoElectronOperatorComponent

template<typename Scalar , size_t N>

using GQCP::TensorMixedUSQTwoElectronOperatorComponent = typedef MixedUSQTwoElectronOperatorComponent<Scalar, TensorVectorizer<N> >

◆ TensorPureUSQTwoElectronOperatorComponent

template<typename Scalar , size_t N>

using GQCP::TensorPureUSQTwoElectronOperatorComponent = typedef PureUSQTwoElectronOperatorComponent<Scalar, TensorVectorizer<N> >

◆ TensorRSQOneElectronOperator

template<typename Scalar , size_t N>

using GQCP::TensorRSQOneElectronOperator = typedef RSQOneElectronOperator<Scalar, TensorVectorizer<N> >

◆ TensorRSQTwoElectronOperator

template<typename Scalar , size_t N>

using GQCP::TensorRSQTwoElectronOperator = typedef RSQTwoElectronOperator<Scalar, TensorVectorizer<N> >

◆ TensorUSQOneElectronOperator

template<typename Scalar , size_t N>

using GQCP::TensorUSQOneElectronOperator = typedef USQOneElectronOperator<Scalar, TensorVectorizer<N> >

◆ TensorUSQOneElectronOperatorComponent

template<typename Scalar , size_t N>

using GQCP::TensorUSQOneElectronOperatorComponent = typedef USQOneElectronOperatorComponent<Scalar, TensorVectorizer<N> >

◆ TensorUSQTwoElectronOperator

template<typename Scalar , size_t N>

using GQCP::TensorUSQTwoElectronOperator = typedef USQTwoElectronOperator<Scalar, TensorVectorizer<N> >

◆ TensorVectorizer

template<size_t A>

using GQCP::TensorVectorizer = typedef DenseVectorizer<A>

◆ UnrestrictedSpinOrbitalTag

using GQCP::UnrestrictedSpinOrbitalTag = typedef UnrestrictedSpinorTag

A tag designating types corresponding to spin-orbitals whose spatial parts may differ.

◆ USpinorBasis

template<typename ExpansionScalar , typename Shell >

using GQCP::USpinorBasis = typedef USpinOrbitalBasis<ExpansionScalar, Shell>

◆ USQHamiltonian

template<typename Scalar >

using GQCP::USQHamiltonian = typedef SQHamiltonian<ScalarUSQOneElectronOperator<Scalar>, ScalarUSQTwoElectronOperator<Scalar> >

◆ Vector

template<typename Scalar , int Rows>

using GQCP::Vector = typedef Matrix<Scalar, Rows, 1>

◆ VectorEvaluableGSQOneElectronOperator

template<typename FunctionType >

using GQCP::VectorEvaluableGSQOneElectronOperator = typedef EvaluableGSQOneElectronOperator<FunctionType, VectorVectorizer>

◆ VectorEvaluableRSQOneElectronOperator

template<typename FunctionType >

using GQCP::VectorEvaluableRSQOneElectronOperator = typedef EvaluableRSQOneElectronOperator<FunctionType, VectorVectorizer>

◆ VectorEvaluableUSQOneElectronOperator

template<typename FunctionType >

using GQCP::VectorEvaluableUSQOneElectronOperator = typedef EvaluableUSQOneElectronOperator<FunctionType, VectorVectorizer>

◆ VectorEvaluableUSQOneElectronOperatorComponent

template<typename FunctionType >

using GQCP::VectorEvaluableUSQOneElectronOperatorComponent = typedef EvaluableUSQOneElectronOperatorComponent<FunctionType, VectorVectorizer>

◆ VectorField

template<typename Scalar >

using GQCP::VectorField = typedef Field<Vector<Scalar, 3> >

◆ VectorFunction

template<typename Scalar >

using GQCP::VectorFunction = typedef std::function<VectorX<Scalar>(const VectorX<Scalar>&)>

◆ VectorGSQOneElectronOperator

template<typename Scalar >

using GQCP::VectorGSQOneElectronOperator = typedef GSQOneElectronOperator<Scalar, VectorVectorizer>

◆ VectorGSQTwoElectronOperator

template<typename Scalar >

using GQCP::VectorGSQTwoElectronOperator = typedef GSQTwoElectronOperator<Scalar, VectorVectorizer>

◆ VectorMixedUSQTwoElectronOperatorComponent

template<typename Scalar >

using GQCP::VectorMixedUSQTwoElectronOperatorComponent = typedef MixedUSQTwoElectronOperatorComponent<Scalar, VectorVectorizer>

◆ VectorPureUSQTwoElectronOperatorComponent

template<typename Scalar >

using GQCP::VectorPureUSQTwoElectronOperatorComponent = typedef PureUSQTwoElectronOperatorComponent<Scalar, VectorVectorizer>

◆ VectorRSQOneElectronOperator

template<typename Scalar >

using GQCP::VectorRSQOneElectronOperator = typedef RSQOneElectronOperator<Scalar, VectorVectorizer>

◆ VectorRSQTwoElectronOperator

template<typename Scalar >

using GQCP::VectorRSQTwoElectronOperator = typedef RSQTwoElectronOperator<Scalar, VectorVectorizer>

◆ VectorUSQOneElectronOperator

template<typename Scalar >

using GQCP::VectorUSQOneElectronOperator = typedef USQOneElectronOperator<Scalar, VectorVectorizer>

◆ VectorUSQOneElectronOperatorComponent

template<typename Scalar >

using GQCP::VectorUSQOneElectronOperatorComponent = typedef USQOneElectronOperatorComponent<Scalar, VectorVectorizer>

◆ VectorUSQTwoElectronOperator

template<typename Scalar >

using GQCP::VectorUSQTwoElectronOperator = typedef USQTwoElectronOperator<Scalar, VectorVectorizer>

◆ VectorVectorizer

using GQCP::VectorVectorizer = typedef DenseVectorizer<1>

◆ VectorX

template<typename Scalar >

using GQCP::VectorX = typedef Vector<Scalar, Dynamic>

Enumeration Type Documentation

◆ CartesianDirection

enum GQCP::CartesianDirection

An enumeration containing the Cartesian directions.

Enumerator
x
y
z

◆ DyadicCartesianDirection

enum GQCP::DyadicCartesianDirection

An enumeration containing the dyadic Cartesian directions.

Enumerator
xx
xy
xz
yx
yy
yz
zx
zy
zz

◆ OccupationType

enum class GQCP::OccupationType

strong

The state of occupation for a spinor (index).

Note: Since 'virtual' is a C++ keyword, the different cases are given a prefix 'k_' for 'constant'.

Enumerator
k_occupied
k_active
k_virtual

◆ Ordering

enum class GQCP::Ordering

strong

An enumeration of possible axis ordering types.

Enumerator
ColumnMajor
RowMajor

◆ Spin

enum GQCP::Spin

A type that can be used to represent the eigenvectors of the S_z operator.

Enumerator
alpha
beta

Function Documentation

◆ calculateElectricPolarizability() [1/2]

Matrix< double, 3, 3 > GQCP::calculateElectricPolarizability	(	const Matrix< double, Dynamic, 3 > &	F_p,
		const Matrix< double, Dynamic, 3 > &	x
	)

Calculate the electric polarizability from the linear wave function response

Parameters

F_p	the electric response force (d^2E/dFdp)
response	the linear wave function response

Returns: the components of the electric polarizability

Calculate the electric polarizability from the linear wave function response

Parameters

F_p	the electric response force (d^2E/dFdp)
x	the linear wave function response

Returns: the components of the electric polarizability

◆ calculateElectricPolarizability() [2/2]

Matrix< double, 3, 3 > GQCP::calculateElectricPolarizability	(	const Matrix< double, Dynamic, 3 > &	F_p,
		const Matrix< double, Dynamic, 3 > &	x,
		const Matrix< double, Dynamic, 3 > &	A_lambda,
		const Matrix< double, Dynamic, 3 > &	y
	)

Calculate the electric polarizability from the linear wave function response and the linear multiplier response

Parameters

F_p	the electric parameter response force
x	the linear wave function response
A_lambda	the first part of the electric multiplier response force
y	the linear multiplier response

Returns: the components of the electric polarizability

◆ calculateRMP2EnergyCorrection()

double GQCP::calculateRMP2EnergyCorrection	(	const RSQHamiltonian< double > &	sq_hamiltonian,
		const QCModel::RHF< double > &	rhf_parameters
	)

Parameters

sq_hamiltonian	the Hamiltonian expressed in an orthornomal basis
rhf_parameters	the converged solution to the RHF SCF equations

Returns: the RMP2 energy correction

◆ calculateSpinSquared()

template<typename Scalar >

double GQCP::calculateSpinSquared	(	const SpinResolved1DM< Scalar > &	one_DMs,
		const SpinResolved2DM< Scalar > &	two_DMs
	)

Calculate the expectation value of the square of the spin angular momentum operator.

Template Parameters

Scalar The scalar type of the density matrices.

Parameters

one_DMs	The one-electron density matrix.
two_DMs	The two-electron density matrix.

Returns: The expectation value of the square of the spin angular momentum operator.

◆ calculateSpinZ()

template<typename Scalar >

double GQCP::calculateSpinZ ( const SpinResolved1DM< Scalar > & one_DMs )

Calculate the expectation value of the z-component of the spin angular momentum operator.

Template Parameters

Scalar The scalar type of the density matrix.

Parameters

one_DMs The one-electron density matrix.

Returns: The expectation value of spin in the z-direction.

◆ cint2e_cart_const()

FINT GQCP::cint2e_cart_const	(	double *	buf,
		const int *	shls,
		const int *	atm,
		int	natm,
		const int *	bas,
		int	nbas,
		const double *	env,
		const CINTOpt *	opt
	)

inline

◆ cint2e_cart_optimizer_const()

void GQCP::cint2e_cart_optimizer_const	(	CINTOpt **	opt,
		const int *	atm,
		int	natm,
		const int *	bas,
		int	nbas,
		const double *	env
	)

inline

◆ conj() [1/2]

complex GQCP::conj ( const complex & c )

Calculate the conjugate of a complex number.

Parameters

c	The complex number.

Returns: The conjugate of the given complex number.

◆ conj() [2/2]

double GQCP::conj ( const double d )

An overload for GQCP::conj for real numbers. This is an identity function.

◆ findElementIndex()

template<typename T >

size_t GQCP::findElementIndex	(	const std::vector< T > &	vector,
		const T &	value
	)

A generalization of std::find

Template Parameters

T	the type of elements stored in the vector

Parameters

vector the vector containing the elements @apram value the value that should be found

Returns: the index of the element that should be found in the given vector

◆ generatePartitionsOf()

std::vector< std::vector< size_t > > GQCP::generatePartitionsOf	(	const size_t	n,
		const size_t	k
	)

◆ generateUniquePartitionsOf()

std::vector< std::vector< size_t > > GQCP::generateUniquePartitionsOf	(	const size_t	n,
		const size_t	k
	)

◆ grayCodeOf()

size_t GQCP::grayCodeOf ( const size_t S )

Parameters

S	the positive integer to be converted to Gray code

Returns: the Gray code of the given integer number as a bitset

◆ make_unique() [1/3]

template<class T , class... Args>

_Unique_if< T >::_Single_object GQCP::make_unique ( Args &&... args )

◆ make_unique() [2/3]

template<class T , class... Args>

_Unique_if< T >::_Known_bound GQCP::make_unique ( Args && ... )

delete

◆ make_unique() [3/3]

template<class T >

_Unique_if< T >::_Unknown_bound GQCP::make_unique ( size_t n )

◆ matrixIndexMajor()

size_t GQCP::matrixIndexMajor	(	const size_t	v,
		const size_t	cols,
		const size_t	skipped = `0`
	)

Parameters

v	the vector index
cols	the number of columns in the matrix
skipped	the number of columns that are skipped in the matrix representation

Returns: the row-major major (non-contiguous) index given the corresponding vector index

◆ matrixIndexMinor()

size_t GQCP::matrixIndexMinor	(	const size_t	v,
		const size_t	cols,
		const size_t	skipped = `0`
	)

Parameters

v	the vector index
cols	the number of columns in the matrix
skipped	the number of columns that are skipped in the matrix representation

Returns: the row-major minor (contiguous) index given the corresponding vector index

◆ newtonStep()

VectorX< double > GQCP::newtonStep	(	const VectorX< double > &	x,
		const VectorFunction< double > &	f,
		const MatrixFunction< double > &	J
	)

Parameters

x	the current point
f	a callable vector function
J	the corresponding Jacobian function

Returns: the Newton step J(x) p = - f

◆ operator*() [1/2]

template<typename F1 , typename F2 , typename = IsFunction<F1>, typename = IsFunction<F2>>

FunctionProduct< F1, F2 > GQCP::operator*	(	const F1 &	lhs,
		const F2 &	rhs
	)

Multiply one function by another.

Template Parameters

F1	The type of the first function.
F2	The type of the second function.

Note: This function is only enabled for actual functions, i.e. functions that derive from Function.

◆ operator*() [2/2]

template<typename Scalar >

ScalarGSQOneElectronOperatorProduct< Scalar > GQCP::operator*	(	const ScalarGSQOneElectronOperator< Scalar > &	lhs,
		const ScalarGSQOneElectronOperator< Scalar > &	rhs
	)

Multiply one scalar, generalized one-electron operator by another.

Template Parameters

Scalar The scalar type of one of the matrix elements: real or complex.

Note: This function assumes that

◆ operator<<() [1/5]

std::ostream & GQCP::operator<<	(	std::ostream &	os,
		const JacobiRotation &	jacobi_rotation
	)

Parameters

os	The output stream which the parameters should be concatenated to.
jacobi_rotation	The Jacobi rotation.

Returns: A reference to the updated output stream.

Examples: /__w/GQCP/GQCP/gqcp/src/ONVBasis/SpinUnresolvedONV.cpp.

◆ operator<<() [2/5]

std::ostream & GQCP::operator<<	(	std::ostream &	os,
		const Molecule &	molecule
	)

Parameters

os	the output stream which the molecule should be concatenated to
molecule	the molecule that should be concatenated to the output stream

Returns: the updated output stream

◆ operator<<() [3/5]

std::ostream & GQCP::operator<<	(	std::ostream &	os,
		const NuclearFramework &	nuclear_framework
	)

Parameters

os	the output stream which the nuclear framework should be concatenated to
nuclear_framework	the nuclear framework that should be concatenated to the output stream

Returns: the updated output stream

◆ operator<<() [4/5]

std::ostream & GQCP::operator<<	(	std::ostream &	os,
		const Nucleus &	nucleus
	)

Overloading of operator<< for a Nucleus to be used with ostreams

Parameters

os	the output stream to which the nucleus should be concatenated
nucleus	the nucleus which should be concatenated to the output stream

Returns: the updated output stream

◆ operator<<() [5/5]

std::ostream & GQCP::operator<<	(	std::ostream &	os,
		const SpinUnresolvedONV &	onv
	)

Parameters

os	The output stream which the ONV should be concatenated to.
onv	The ONV that should be concatenated to the output stream.

Returns: The updated output stream.

◆ printExecutionTime()

void GQCP::printExecutionTime	(	const std::string &	method_name,
		const std::function< void()> &	function
	)

Print the time a function takes to be executed

Parameters

method_name	the name of function that is to be executed
function	the function call to be made

◆ rotate() [1/2]

template<typename RotationType , typename First , typename... Others>

void GQCP::rotate	(	const RotationType &	U,
		First &	first,
		Others &...	others
	)

Basis rotate a number of objects with a given transformation.

Template Parameters

RotationType	The type of the basis rotated.
First	The type of the first object that should be basis rotated.
Others	The variadic type of the other objects that should be basis rotated.

Parameters

U	The basis rotation.
first	The first object that should be basis transformed.
others	The variadic other objects that should be basis transformed.

◆ rotate() [2/2]

template<typename RotationType , typename RotatableType >

void GQCP::rotate	(	const RotationType &	U,
		RotatableType &	rotatable
	)

Break the recursion of the variadic rotate method: rotate a single object with a basis rotation.

Template Parameters

RotationType	The type of the basis rotation.
RotatableType	The type of the object that should be basis rotated.

Parameters

U	The basis rotation.
rotatable	The object that should be basis rotated.

◆ strictTriangularRootOf()

size_t GQCP::strictTriangularRootOf ( const size_t x )

Parameters

x	the number

Returns: the strict triangular root of the given number. This is also the dimension of the square matrix whose strict lower/upper triangle has the given number of elements

◆ transform() [1/2]

template<typename TransformationType , typename First , typename... Others>

void GQCP::transform	(	const TransformationType &	T,
		First &	first,
		Others &...	others
	)

Basis transform a number of objects with a given transformation.

Template Parameters

TransformationType	The type of the basis transformation.
First	The type of the first object that should be basis transformed.
Others	The variadic type of the other objects that should be basis transformed.

Parameters

T	The basis transformation.
first	The first object that should be basis transformed.
others	The variadic other objects that should be basis transformed.

◆ transform() [2/2]

template<typename TransformationType , typename TransformableType >

void GQCP::transform	(	const TransformationType &	T,
		TransformableType &	transformable
	)

Break the recursion of the variadic transform method: transform a single object with a basis transformation.

Template Parameters

TransformationType	The type of the basis transformation.
TransformableType	The type of the object that should be basis transformed.

Parameters

T	The basis transformation.
transformable	The object that should be basis transformed.

◆ triangularRootOf()

size_t GQCP::triangularRootOf ( const size_t x )

Parameters

x	the number

Returns: the triangular root of the given number. This is also the dimension of the square matrix whose lower/upper triangle has the given number of elements

◆ validateAndOpen()

std::ifstream GQCP::validateAndOpen	(	const std::string &	filename,
		const std::string &	extension
	)

Parameters

filename	the name of the file that should be opened
extension	the expected extension of the filename

◆ vectorIndex()

size_t GQCP::vectorIndex	(	const size_t	i,
		const size_t	j,
		const size_t	cols,
		size_t	skipped = `0`
	)

Parameters

i	the row index
j	the column index
cols	the number of columns in de matrix
skipped	the number of columns that are skipped in the matrix representation

Returns: the vector index given the corresponding row-major matrix indices

Variable Documentation

◆ Dynamic

constexpr auto GQCP::Dynamic = Eigen::Dynamic

constexpr

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

◆ ArrayX

◆ ArrayXX

◆ BaseMatrixFQOneElectronOperator

◆ BaseMatrixFQTwoElectronOperator

◆ BaseScalarFQOneElectronOperator

◆ BaseScalarFQTwoElectronOperator

◆ BaseTensorFQOneElectronOperator

◆ BaseTensorFQTwoElectronOperator

◆ BaseVectorFQOneElectronOperator

◆ BaseVectorFQTwoElectronOperator

◆ complex

◆ enable_if_t

◆ GSQHamiltonian

◆ IsComplex

◆ IsFunction

◆ IsReal

◆ Libcint1eFunction

◆ Libcint2eFunction

◆ Libcint2eOptimizerFunction

◆ MatrixEvaluableGSQOneElectronOperator

◆ MatrixEvaluableRSQOneElectronOperator

◆ MatrixEvaluableUSQOneElectronOperator

◆ MatrixEvaluableUSQOneElectronOperatorComponent

◆ MatrixField

◆ MatrixFunction

◆ MatrixGSQOneElectronOperator

◆ MatrixGSQTwoElectronOperator

◆ MatrixMixedUSQTwoElectronOperatorComponent

◆ MatrixPureUSQTwoElectronOperatorComponent

◆ MatrixRSQOneElectronOperator

◆ MatrixRSQTwoElectronOperator

◆ MatrixUSQOneElectronOperator

◆ MatrixUSQOneElectronOperatorComponent

◆ MatrixUSQTwoElectronOperator

◆ MatrixVectorizer

◆ MatrixX

◆ product_t

◆ RestrictedSpinOrbitalTag

◆ RSpinorBasis

◆ RSQHamiltonian

◆ ScalarEvaluableGSQOneElectronOperator

◆ ScalarEvaluableRSQOneElectronOperator

◆ ScalarEvaluableUSQOneElectronOperator

◆ ScalarEvaluableUSQOneElectronOperatorComponent

◆ ScalarGSQOneElectronOperator

◆ ScalarGSQTwoElectronOperator

◆ ScalarMixedUSQTwoElectronOperatorComponent

◆ ScalarPureUSQTwoElectronOperatorComponent

◆ ScalarRSQOneElectronOperator

◆ ScalarRSQTwoElectronOperator

◆ ScalarUSQOneElectronOperator

◆ ScalarUSQOneElectronOperatorComponent

◆ ScalarUSQTwoElectronOperator

◆ ScalarVectorizer

◆ sum_t

◆ TensorEvaluableGSQOneElectronOperator

◆ TensorEvaluableRSQOneElectronOperator

◆ TensorEvaluableUSQOneElectronOperator

◆ TensorEvaluableUSQOneElectronOperatorComponent

◆ TensorGSQOneElectronOperator

◆ TensorGSQTwoElectronOperator

◆ TensorMixedUSQTwoElectronOperatorComponent

◆ TensorPureUSQTwoElectronOperatorComponent

◆ TensorRSQOneElectronOperator

◆ TensorRSQTwoElectronOperator

◆ TensorUSQOneElectronOperator

◆ TensorUSQOneElectronOperatorComponent

◆ TensorUSQTwoElectronOperator

◆ TensorVectorizer

◆ UnrestrictedSpinOrbitalTag

◆ USpinorBasis

◆ USQHamiltonian