OperatorSpace< ScalarType > Class Template Reference

#include <OperatorSpace.hpp>

Inheritance diagram for OperatorSpace< ScalarType >:

Collaboration diagram for OperatorSpace< ScalarType >:

Public Types
using	BaseSpace = typename HilbertSpaceTraits< OperatorSpace >::BaseSpace
using	Scalar = ScalarType
Public Types inherited from OperatorSpaceBase< Derived >
typedef Eigen::NumTraits< ScalarType >::Real	Real

Private Member Functions
__host__ __device__ int	dim_impl () const
template<typename RealType >
__host__ __device__ void	action_impl (int &resBasisNum, Complex_t< RealType > &coeff, int opNum, int basisNum) const

Private Attributes
friend	HilbertSpace< OperatorSpace >
friend	OperatorSpaceBase< OperatorSpace >

Additional Inherited Members
Public Member Functions inherited from OperatorSpaceBase< Derived >
__host__ __device__	OperatorSpaceBase (BaseSpace const &baseSpace)
	Construct a OperatorSpaceBase object by copying a BaseSpace object.
__host__ __device__	OperatorSpaceBase (BaseSpace &&baseSpace)
	Construct a OperatorSpaceBase object by moving a BaseSpace object.
__host__ __device__	OperatorSpaceBase ()=default
	Default constructor.
__host__ __device__	OperatorSpaceBase (OperatorSpaceBase const &other)=default
	Copy constructor.
__host__ __device__	OperatorSpaceBase (OperatorSpaceBase &&other)=default
	Move constructor.
__host__ __device__	~OperatorSpaceBase ()=default
	Destructor.
__host__ __device__ OperatorSpaceBase &	operator= (OperatorSpaceBase const &other)=default
	Copy assignment operator.
__host__ __device__ OperatorSpaceBase &	operator= (OperatorSpaceBase &&other)=default
	Move assignment operator.
__host__ __device__ int	dim () const
__host__ __device__ BaseSpace const &	baseSpace () const
__host__ __device__ int	baseDim () const
template<typename RealType >
__host__ __device__ void	action (int &resBasisNum, Complex_t< RealType > &coeff, int opNum, int basisNum) const
template<typename RealType , class EigenDerived >
__host__ __device__ void	action (int &resBasisNum, Complex_t< RealType > &coeff, int opNum, int basisNum, Eigen::DenseBase< EigenDerived > &config) const
__host__ __device__ std::pair< int, Complex_t< Real > >	action (int opNum, int basisNum) const
__host__ void	basisOp (Eigen::SparseMatrix< ScalarType > &res, int opNum) const
__host__ Eigen::SparseMatrix< ScalarType >	basisOp (int opNum) const

Member Typedef Documentation

BaseSpace

template<typename ScalarType = Complex_t<Real_t>>

using OperatorSpace< ScalarType >::BaseSpace = typename HilbertSpaceTraits<OperatorSpace>::BaseSpace

Scalar

template<typename ScalarType = Complex_t<Real_t>>

using OperatorSpace< ScalarType >::Scalar = ScalarType

Member Function Documentation

action_impl()

template<typename ScalarType = Complex_t<Real_t>>

template<typename RealType >

__host__ __device__ void OperatorSpace< ScalarType >::action_impl ( int &  resBasisNum, Complex_t< RealType > &  coeff, int  opNum, int  basisNum  ) const

inlineprivate

Variant of sigma Z

Variant of sigma X

Variant of sigma Y

                                                                            {
            // debug_printf("%s\n", __PRETTY_FUNCTION__);
            resBasisNum = basisNum;
            coeff       = {0.0, 0.0};
            int Digit1, Digit2;
 
            if(opNum < this->baseSpace().dim()) {
                resBasisNum = basisNum;
                if(opNum == 0) { coeff = 1.0 / RealType(sqrt(RealType(this->baseSpace().dim()))); }
                else if(opNum == 1 && this->baseSpace().dim() % 2 == 0) {
                    coeff = (basisNum % 2 == 0 ? 1.0 : -1.0)
                            / RealType(sqrt(RealType(this->baseSpace().dim())));
                }
                else {
                    coeff = sin(M_PI
                                * (2 * (opNum / 2) * basisNum / RealType(this->baseSpace().dim())
                                   + (opNum % 2) / 2.0))
                            / RealType(sqrt(RealType(this->baseSpace().dim()) / 2.0));
                    ;
                }
            }
            else if(opNum < this->baseSpace().dim() * (this->baseSpace().dim() + 1) / 2) {
                opNum -= this->baseSpace().dim();
                Digit1 = int(sqrt(RealType(2 * opNum) + 0.25) + 0.5);
                Digit2 = opNum - Digit1 * (Digit1 - 1) / 2;
                if(Digit1 == basisNum) {
                    resBasisNum = Digit2;
                    coeff       = Complex_t<RealType>(1.0 / sqrt(RealType(2)), 0.0);
                }
                else if(Digit2 == basisNum) {
                    resBasisNum = Digit1;
                    coeff       = Complex_t<RealType>(1.0 / sqrt(RealType(2)), 0.0);
                }
            }
            else if(opNum < this->baseSpace().dim() * this->baseSpace().dim()) {
                opNum -= this->baseSpace().dim() * (this->baseSpace().dim() + 1) / 2;
                Digit1 = int(sqrt(RealType(2 * opNum) + 0.25) + 0.5);
                Digit2 = opNum - Digit1 * (Digit1 - 1) / 2;
                if(Digit1 == basisNum) {
                    resBasisNum = Digit2;
                    coeff       = Complex_t<RealType>(0.0, -1.0 / sqrt(RealType(2)));
                }
                else if(Digit2 == basisNum) {
                    resBasisNum = Digit1;
                    coeff       = Complex_t<RealType>(0.0, +1.0 / sqrt(RealType(2)));
                }
            }
            else {
                // clang-format off
                #ifndef __CUDA_ARCH__
                std::cerr << "Error: " << __PRETTY_FUNCTION__ << "\n\t"
                          << " opNum(" << opNum << ") must be less than "
                          << this->baseSpace().dim() * this->baseSpace().dim() << std::endl;
                std::exit(EXIT_FAILURE);
                #endif
                // clang-format on
            }
            return;
        };

dim_impl()

template<typename ScalarType = Complex_t<Real_t>>

__host__ __device__ int OperatorSpace< ScalarType >::dim_impl ( ) const

inlineprivate

                                                 {
            return this->baseSpace().dim() * this->baseSpace().dim();
        }

Member Data Documentation

HilbertSpace< OperatorSpace >

template<typename ScalarType = Complex_t<Real_t>>

friend OperatorSpace< ScalarType >::HilbertSpace< OperatorSpace >

private

OperatorSpaceBase< OperatorSpace >

template<typename ScalarType = Complex_t<Real_t>>

friend OperatorSpace< ScalarType >::OperatorSpaceBase< OperatorSpace >

private

---

The documentation for this class was generated from the following file:

• /Users/shoki/GitHub/Locality/Headers/HilbertSpace/OperatorSpace.hpp