statmech.cpp File Reference

Functions
Integer_t	EigenValues (std::vector< double > &Eigenvalue, Integer_t const dim, matrix< Complex_t< double > > &Hamiltonian)
double	SpectralRange (double &OpMin, Integer_t const dim, matrix< Complex_t< double > > &Operator)
Integer_t	Diagonalize (Integer_t const dim, matrix< Complex_t< double > > &Hamiltonian, std::vector< double > &Eigenvalue)
Integer_t	EigenMatrixElements (std::vector< double > &Eigenvalue, Integer_t const dim, matrix< Complex_t< double > > &Hamiltonian, matrix< Complex_t< double > > &Operator, void *GPUconf)
Integer_t	EigenExpValue (std::vector< double > &EXPvalue, std::vector< double > &Eigenvalue, Integer_t const dim, matrix< Complex_t< double > > &Hamiltonian, const matrix< Complex_t< double > > &Operator, void *GPUconf)
void	DensityOfStates (std::vector< double > &res, std::vector< double > const &Position, std::vector< double > const &Eigenvalue, std::function< double(double)> Kernel)
void	KernelAverage (std::vector< double > &res, std::vector< double > const &Position, std::vector< double > const &RawData, std::vector< double > const &Eigenvalue, std::function< double(double)> Kernel)
double	MicroCanonicalAverage (Integer_t &NdataInShell, double const Energy, double const shellWidth, Integer_t const dim, std::vector< double > const &Eigenvalue, std::vector< double > const &EXPvalue, Integer_t const initId)
void	MicroCanonicalAverage (std::vector< double > &MCAverage, std::vector< Integer_t > &NdataInShell, double const shellWidth, const std::vector< std::tuple< double, double > > Data)
void	MicroCanonicalAverage (std::vector< double > &MCAverage, std::vector< Integer_t > &NdataInShell, double const shellWidth, const std::vector< std::tuple< double, double, Integer_t > > Data)
Integer_t	MeasureOfETH (double &Fluc_2, double &Fluc_inf, double &MaxPos, double const Emin, double const Emax, Integer_t const dim, const std::vector< double > &eigenEnergy, const std::vector< double > &EXPvalue, const std::vector< double > &MCAverage)
std::tuple< double, double, double, Integer_t >	MeasureOfETH (double const Emin, double const Emax, Integer_t const dim, const std::vector< double > &eigenEnergy, const std::vector< double > &EXPvalue, const std::vector< double > &MCAverage)
template<class... Args>
Integer_t	MeasureOfETH (double &Fluc_2, double &Fluc_inf, double &MaxPos, double const Emin, double const Emax, const std::vector< double > &MCAverage, const std::vector< std::tuple< double, double, Args... > > Data)
template Integer_t	MeasureOfETH (double &Fluc_2, double &Fluc_inf, double &MaxPos, double const Emin, double const Emax, const std::vector< double > &MCAverage, const std::vector< std::tuple< double, double > > Data)
template Integer_t	MeasureOfETH< Integer_t > (double &Fluc_2, double &Fluc_inf, double &MaxPos, double const Emin, double const Emax, const std::vector< double > &MCAverage, const std::vector< std::tuple< double, double, Integer_t > > Data)
void	LevelSpacingRatio (std::vector< double > &result, double const Emin, double const Emax, Integer_t const dim, const std::vector< double > &eigenEnergy)
template<typename Type >
std::tuple< std::vector< double >, std::vector< double >, std::vector< double > >	OverlapSqVsEnergy (Integer_t const NDIV, Integer_t const dim, std::vector< double > const &Energy1, std::vector< double > const &Energy2, matrix< Type > const &OverlapSq)
template std::tuple< std::vector< double >, std::vector< double >, std::vector< double > >	OverlapSqVsEnergy (Integer_t const NDIV, Integer_t const dim, std::vector< double > const &Energy1, std::vector< double > const &EnergyRange2, matrix< double > const &OverlapSq)
template std::tuple< std::vector< double >, std::vector< double >, std::vector< double > >	OverlapSqVsEnergy (Integer_t const NDIV, Integer_t const dim, std::vector< double > const &Energy1, std::vector< double > const &EnergyRange2, matrix< Complex_t< float > > const &OverlapSq)
template std::tuple< std::vector< double >, std::vector< double >, std::vector< double > >	OverlapSqVsEnergy (Integer_t const NDIV, Integer_t const dim, std::vector< double > const &Energy1, std::vector< double > const &EnergyRange2, matrix< Complex_t< double > > const &OverlapSq)

Function Documentation

DensityOfStates()

void DensityOfStates	(	std::vector< double > &	res,
		std::vector< double > const &	Position,
		std::vector< double > const &	Eigenvalue,
		std::function< double(double)>	Kernel
	)

                                                                                              {
    res.resize(Position.size());
    std::fill(res.begin(), res.end(), 0.0);
    for(size_t j = 0; j < Position.size(); ++j) {
        for(size_t alpha = 0; alpha < Eigenvalue.size(); ++alpha)
            res[j] += Kernel(Position[alpha] - Eigenvalue[alpha]);
    }
}

Diagonalize()

Integer_t Diagonalize	(	Integer_t const	dim,
		matrix< Complex_t< double > > &	Hamiltonian,
		std::vector< double > &	Eigenvalue
	)

                                                     {
    debug_print("# " << __func__ << "(CPU)");
    //********** Variables for LAPACK and BLASS **********//
    Integer_t                        DIM = dim, LD = Hamiltonian.LD();
    std::vector<Complex_t<double>> work(1);
    std::vector<double>              rwork(1);
    std::vector<Integer_t>           iwork(1);
    Integer_t                        lwork = -1, lrwork = -1, liwork = -1;
    char                             JOBS = 'V', UPLO = 'U';
    Integer_t                        info;
    //********** (END)Variables for LAPACK and BLASS **********//
    //********** Query for work space sizes (lwork, lrwork, liwork) **********//
    zheevd_(&JOBS, &UPLO, &DIM, &*Hamiltonian.begin(), &LD, nullptr, &*work.begin(), &lwork,
            &*rwork.begin(), &lrwork, &liwork, &liwork, &info);
    lwork  = (Integer_t)real(work[0]);
    lrwork = (Integer_t)rwork[0];
    //********** (END)Query for work space sizes (lwork, lrwork, liwork) **********//
    //********** Allocation **********//
    work.resize(lwork);
    rwork.resize(lrwork);
    iwork.resize(liwork);
    //********** (END)Allocation **********//
    zheevd_(&JOBS, &UPLO, &DIM, &*Hamiltonian.begin(), &LD, &*Eigenvalue.begin(), &*work.begin(),
            &lwork, &*rwork.begin(), &lrwork, &*iwork.begin(), &liwork, &info);
    if(info != 0) std::cerr << "Error: LAPACK::zheevd failed." << std::endl;
    return info;
}

EigenExpValue()

Integer_t EigenExpValue	(	std::vector< double > &	EXPvalue,
		std::vector< double > &	Eigenvalue,
		Integer_t const	dim,
		matrix< Complex_t< double > > &	Hamiltonian,
		const matrix< Complex_t< double > > &	Operator,
		void *	GPUconf
	)

                                                                                  {
    debug_print("# " << __func__ << "(CPU)");
    Integer_t info = Diagonalize(dim, Hamiltonian, Eigenvalue);
    if(info != 0) std::exit(EX_SOFTWARE);
 
    Integer_t                        LD = Hamiltonian.LD();
    std::vector<Complex_t<double>> intermediate(dim);
    for(Integer_t i = 0; i < dim; ++i) {
        EXPvalue[i] = QuantumExpValue_he(dim, Hamiltonian.begin() + LD * i, Operator, intermediate);
    }
    return info;
}

EigenMatrixElements()

Integer_t EigenMatrixElements	(	std::vector< double > &	Eigenvalue,
		Integer_t const	dim,
		matrix< Complex_t< double > > &	Hamiltonian,
		matrix< Complex_t< double > > &	Operator,
		void *	GPUconf
	)

                                                                                  {
    debug_print("# " << __func__ << "(CPU)");
    Eigenvalue.resize(dim);
    std::fill(Eigenvalue.begin(), Eigenvalue.end(), 0);
    Integer_t info = Diagonalize(dim, Hamiltonian, Eigenvalue);
    if(info != 0) std::exit(info);
 
    //********** Variables for BLAS
    Integer_t                   DIM   = dim;
    Integer_t                   HmLD  = Hamiltonian.LD();
    Integer_t                   OpLD  = Operator.LD();
    char                        sideL = 'L', uploU = 'U';
    char                        ntrans = 'N', ctrans = 'C';
    Complex_t<double>         alpha = DoubleComplexOne, beta = DoubleComplexZero;
    matrix<Complex_t<double>> intermediate(dim, dim);
    //********** (END) Variables for BLAS
 
    zhemm_(&sideL, &uploU, &DIM, &DIM, &alpha, &*Operator.begin(), &OpLD, &*Hamiltonian.begin(),
           &HmLD, &beta, &*intermediate.begin(), &DIM);
    zgemm_(&ctrans, &ntrans, &DIM, &DIM, &DIM, &alpha, &*Hamiltonian.begin(), &HmLD,
           &*intermediate.begin(), &DIM, &beta, &*Operator.begin(), &OpLD);
    return info;
}

EigenValues()

Integer_t EigenValues	(	std::vector< double > &	Eigenvalue,
		Integer_t const	dim,
		matrix< Complex_t< double > > &	Hamiltonian
	)

                                                              {
    debug_print("# " << __func__ << "(CPU)");
    Eigenvalue.resize(dim);
    //********** Variables for LAPACK and BLASS **********//
    Integer_t                        DIM = dim, LD = Hamiltonian.LD();
    std::vector<Complex_t<double>> work(1);
    std::vector<double>              rwork(1);
    std::vector<Integer_t>           iwork(1);
    Integer_t                        lwork = -1, lrwork = -1, liwork = -1;
    char                             JOBS = 'N', UPLO = 'U';
    Integer_t                        info;
    //********** (END)Variables for LAPACK and BLASS **********//
    //********** Query for work space sizes (lwork, lrwork, liwork) **********//
    zheevd_(&JOBS, &UPLO, &DIM, &*Hamiltonian.begin(), &LD, nullptr, &*work.begin(), &lwork,
            &*rwork.begin(), &lrwork, &liwork, &liwork, &info);
    lwork  = (Integer_t)real(work[0]);
    lrwork = (Integer_t)rwork[0];
    //********** (END)Query for work space sizes (lwork, lrwork, liwork) **********//
    //********** Allocation **********//
    work.resize(lwork);
    rwork.resize(lrwork);
    iwork.resize(liwork);
    //********** (END)Allocation **********//
    zheevd_(&JOBS, &UPLO, &DIM, &*Hamiltonian.begin(), &LD, &*Eigenvalue.begin(), &*work.begin(),
            &lwork, &*rwork.begin(), &lrwork, &*iwork.begin(), &liwork, &info);
    if(info != 0) std::cerr << "Error: LAPACK::zheevd failed." << std::endl;
    return info;
}

KernelAverage()

void KernelAverage	(	std::vector< double > &	res,
		std::vector< double > const &	Position,
		std::vector< double > const &	RawData,
		std::vector< double > const &	Eigenvalue,
		std::function< double(double)>	Kernel
	)

                                                       {
    res.resize(Position.size());
    std::fill(res.begin(), res.end(), 0.0);
    for(size_t j = 0; j < Position.size(); ++j) {
        for(size_t alpha = 0; alpha < Eigenvalue.size(); ++alpha)
            res[j] += RawData.at(alpha) * Kernel(Position[alpha] - Eigenvalue[alpha]);
    }
}

LevelSpacingRatio()

void LevelSpacingRatio	(	std::vector< double > &	result,
		double const	Emin,
		double const	Emax,
		Integer_t const	dim,
		const std::vector< double > &	eigenEnergy
	)

                                                                                  {
    Integer_t idMin, idMax;
    for(idMin = 0; eigenEnergy[idMin] < Emin && idMin < dim; ++idMin) {};
    for(idMax = dim - 1; eigenEnergy[idMax] > Emax && idMax >= 0; --idMax) {};
    Integer_t Ndata = idMax - idMin + 1;
    double    s;
    std::fill(result.begin(), result.end(), 0);
    if(Ndata < 2) return;
    result.resize(Ndata - 2);
    for(Integer_t j = 0; j < Ndata - 2; ++j) {
        s = (eigenEnergy[idMin + j + 2] - eigenEnergy[idMin + j + 1])
            / (eigenEnergy[idMin + j + 1] - eigenEnergy[idMin + j]);
        if(s > 1) result[j] = 1.0 / s;
        else result[j] = s;
    }
}

MeasureOfETH() [1/4]

template Integer_t MeasureOfETH	(	double &	Fluc_2,
		double &	Fluc_inf,
		double &	MaxPos,
		double const	Emin,
		double const	Emax,
		const std::vector< double > &	MCAverage,
		const std::vector< std::tuple< double, double > >	Data
	)

MeasureOfETH() [2/4]

template<class... Args>

Integer_t MeasureOfETH	(	double &	Fluc_2,
		double &	Fluc_inf,
		double &	MaxPos,
		double const	Emin,
		double const	Emax,
		const std::vector< double > &	MCAverage,
		const std::vector< std::tuple< double, double, Args... > >	Data
	)

                                                                                {
    Integer_t Ndata = 0, dim = Data.size();
    double    fluc;
    Fluc_2   = 0;
    Fluc_inf = 0;
    MaxPos   = 0;
    for(Integer_t i = 0; i < dim && std::get<0>(Data[i]) <= Emax; ++i) {
        if(std::get<0>(Data[i]) < Emin) continue;
        fluc = std::get<1>(Data[i]) - MCAverage[i];
        if(isnan(fluc)) continue;
        Fluc_2 += fluc * fluc;
        Ndata += 1;
        if(fabs(fluc) > Fluc_inf) {
            Fluc_inf = fabs(fluc);
            MaxPos   = std::get<0>(Data[i]);
        }
    }
    Fluc_2 = sqrt(Fluc_2 / (double)(Ndata - 1));
    return Ndata;
}

MeasureOfETH() [3/4]

Integer_t MeasureOfETH	(	double &	Fluc_2,
		double &	Fluc_inf,
		double &	MaxPos,
		double const	Emin,
		double const	Emax,
		Integer_t const	dim,
		const std::vector< double > &	eigenEnergy,
		const std::vector< double > &	EXPvalue,
		const std::vector< double > &	MCAverage
	)

                                                           {
    Integer_t Ndata = 0;
    double    fluc;
    Fluc_2   = 0;
    Fluc_inf = 0;
    MaxPos   = 0;
    for(Integer_t i = 0; i < dim && eigenEnergy[i] <= Emax; ++i) {
        if(eigenEnergy[i] < Emin) continue;
        fluc = EXPvalue[i] - MCAverage[i];
        if(isnan(fluc)) continue;
        Fluc_2 += fluc * fluc;
        Ndata += 1;
        if(fabs(fluc) > Fluc_inf) {
            Fluc_inf = fabs(fluc);
            MaxPos   = eigenEnergy[i];
        }
    }
    Fluc_2 = sqrt(Fluc_2 / (double)(Ndata - 1));
    return Ndata;
}

MeasureOfETH() [4/4]

std::tuple< double, double, double, Integer_t > MeasureOfETH	(	double const	Emin,
		double const	Emax,
		Integer_t const	dim,
		const std::vector< double > &	eigenEnergy,
		const std::vector< double > &	EXPvalue,
		const std::vector< double > &	MCAverage
	)

                                                                                               {
    double    Fluc_2, Fluc_inf, MaxPos;
    Integer_t Ndata
        = MeasureOfETH(Fluc_2, Fluc_inf, MaxPos, Emin, Emax, dim, eigenEnergy, EXPvalue, MCAverage);
    return {Fluc_2, Fluc_inf, MaxPos, Ndata};
}

MeasureOfETH< Integer_t >()

template Integer_t MeasureOfETH< Integer_t >	(	double &	Fluc_2,
		double &	Fluc_inf,
		double &	MaxPos,
		double const	Emin,
		double const	Emax,
		const std::vector< double > &	MCAverage,
		const std::vector< std::tuple< double, double, Integer_t > >	Data
	)

MicroCanonicalAverage() [1/3]

double MicroCanonicalAverage	(	Integer_t &	NdataInShell,
		double const	Energy,
		double const	shellWidth,
		Integer_t const	dim,
		std::vector< double > const &	Eigenvalue,
		std::vector< double > const &	EXPvalue,
		Integer_t const	initId
	)

                                                                                        {
    Integer_t idMin, idMax;
    for(idMin = initId; Eigenvalue[idMin] < Energy - shellWidth && idMin >= 0; ++idMin) {};
    for(; Eigenvalue[idMin] >= Energy - shellWidth && idMin >= 0; --idMin) {};
    ++idMin;
    for(idMax = idMin; Eigenvalue[idMax] <= Energy + shellWidth && idMax < dim; ++idMax) {};
    --idMax;
    double MCAverage = 0;
    NdataInShell     = 0;
    if(dim < idMax) {
        std::cout << "idMin = " << idMin << ", idMax = " << idMax << ", dim = " << dim << std::endl;
    }
    for(Integer_t j = idMin; j <= idMax; ++j) {
        if(isnan(EXPvalue[j])) continue;
        MCAverage += EXPvalue[j];
        NdataInShell += 1;
    }
    MCAverage /= (double)NdataInShell;
    return MCAverage;
}

MicroCanonicalAverage() [2/3]

void MicroCanonicalAverage	(	std::vector< double > &	MCAverage,
		std::vector< Integer_t > &	NdataInShell,
		double const	shellWidth,
		const std::vector< std::tuple< double, double > >	Data
	)

                                                                           {
    Integer_t const dim = Data.size();
    double          shellEnergy;
    //******************** Initialization ********************
    MCAverage.resize(dim);
    std::fill(MCAverage.begin(), MCAverage.end(), 0);
    NdataInShell.resize(dim);
    std::fill(NdataInShell.begin(), NdataInShell.end(), 0);
    //******************** (END)Initialization ********************
    Integer_t Ndata, idMin, idMax;
    for(Integer_t i = 0; i < dim; ++i) {
        shellEnergy = std::get<0>(Data[i]);
        for(idMin = i; std::get<0>(Data[idMin]) >= shellEnergy - shellWidth && idMin >= 0;
            --idMin) {};
        ++idMin;
        for(idMax = i; std::get<0>(Data[idMax]) <= shellEnergy + shellWidth && idMax < dim;
            ++idMax) {};
        --idMax;
        Ndata = 0;
        for(Integer_t j = idMin; j <= idMax; ++j) {
            if(isnan(std::get<1>(Data[j]))) continue;
            MCAverage[i] += std::get<1>(Data[j]);
            Ndata += 1;
        }
        NdataInShell[i] = Ndata;
        MCAverage[i] /= (double)Ndata;
    }
}

MicroCanonicalAverage() [3/3]

void MicroCanonicalAverage	(	std::vector< double > &	MCAverage,
		std::vector< Integer_t > &	NdataInShell,
		double const	shellWidth,
		const std::vector< std::tuple< double, double, Integer_t > >	Data
	)

                                                                                      {
    Integer_t const dim = Data.size();
    double          shellEnergy;
    //******************** Initialization ********************
    MCAverage.resize(dim);
    std::fill(MCAverage.begin(), MCAverage.end(), 0);
    NdataInShell.resize(dim);
    std::fill(NdataInShell.begin(), NdataInShell.end(), 0);
    //******************** (END)Initialization ********************
    Integer_t Ndata, idMin, idMax;
    for(Integer_t i = 0; i < dim; ++i) {
        shellEnergy = std::get<0>(Data[i]);
        for(idMin = i; std::get<0>(Data[idMin]) >= shellEnergy - shellWidth && idMin >= 0;
            --idMin) {};
        ++idMin;
        for(idMax = i; std::get<0>(Data[idMax]) <= shellEnergy + shellWidth && idMax < dim;
            ++idMax) {};
        --idMax;
        Ndata = 0;
        for(Integer_t j = idMin; j <= idMax; ++j) {
            if(isnan(std::get<1>(Data[j]))) continue;
            MCAverage[i] += std::get<1>(Data[j]) * std::get<2>(Data[j]);
            Ndata += std::get<2>(Data[j]);
        }
        NdataInShell[i] = Ndata;
        MCAverage[i] /= (double)Ndata;
    }
}

OverlapSqVsEnergy() [1/4]

template<typename Type >

std::tuple< std::vector< double >, std::vector< double >, std::vector< double > > OverlapSqVsEnergy	(	Integer_t const	NDIV,
		Integer_t const	dim,
		std::vector< double > const &	Energy1,
		std::vector< double > const &	Energy2,
		matrix< Type > const &	OverlapSq
	)

                                          {  // Calculate Energy dependence of overlaps
    debug_print("# " << __func__);
    double const Emin1        = *std::min_element(Energy1.begin(), Energy1.end());
    double const Emax1        = *std::max_element(Energy1.begin(), Energy1.end());
    double const Emin2        = *std::min_element(Energy2.begin(), Energy2.end());
    double const Emax2        = *std::max_element(Energy2.begin(), Energy2.end());
    double const EnergyRange1 = Emax1 - Emin1;
    double const EnergyRange2 = Emax2 - Emin2;
    debug_print("Emax1=" << Emax1 << ", Emax2=" << Emax2 << ", NDIV=" << NDIV
                         << ", EnergyRange1=" << EnergyRange1 << ", EnergyRange2=" << EnergyRange2);
    auto Bin1 = [&](double x) {
        return (x == Emax1 ? NDIV - 1 : (Integer_t)(NDIV * (x - Emin1) / EnergyRange1));
    };
    auto Bin2 = [&](double x) {
        return (x == Emax2 ? NDIV - 1 : (Integer_t)(NDIV * (x - Emin2) / EnergyRange2));
    };
 
    std::vector<std::vector<Integer_t>> binElem1(NDIV);
    std::vector<std::vector<Integer_t>> binElem2(NDIV);
    for(size_t j = 0; j < dim; ++j) {
        binElem1.at(Bin1(Energy1[j])).push_back(j);
        binElem2.at(Bin2(Energy2[j])).push_back(j);
    }
    double norm, meanNorm, prob, probOld, dtemp;
 
    std::vector<double> mean(NDIV, 0), sigma(NDIV, 0), DOS(NDIV);
    std::vector<double> aveOverlapSq(NDIV);
#pragma omp parallel for
    for(size_t bin1 = 0; bin1 < NDIV; ++bin1)
        DOS[bin1] = binElem2[bin1].size() * NDIV / (double)dim;
    for(size_t bin1 = 0; bin1 < NDIV; ++bin1) {
        if(binElem2[bin1].size() == 0) {
            mean[bin1] = sigma[bin1] = NAN;
            continue;
        }
        std::fill(aveOverlapSq.begin(), aveOverlapSq.end(), 0.0);
        norm = 0;
        for(size_t bin0 = 0; bin0 < NDIV; ++bin0) {
            if(binElem1[bin0].size() == 0) continue;
            for(const auto& j: binElem2[bin1])
                for(const auto& i: binElem1[bin0]) {
                    aveOverlapSq[bin0] += real(OverlapSq.at(i, j));
                }
            if(binElem2[bin1].size() * binElem1[bin0].size() != 0) {
                aveOverlapSq[bin0] /= binElem2[bin1].size() * binElem1[bin0].size();
                norm += aveOverlapSq[bin0];
            }
        }
        prob     = 0;
        meanNorm = 0;
        for(size_t bin0 = 0; bin0 < NDIV; ++bin0) {
            if(binElem1[bin0].size() == 0) continue;
            probOld = prob;
            dtemp   = aveOverlapSq[bin0] / norm;
            prob += dtemp;
            if(0.5 - 0.12 <= prob && prob <= 0.5 + 0.12) {
                meanNorm += dtemp;
                mean[bin1] += dtemp * bin0 / (double)NDIV;
            }
            else if(probOld < 0.5 - 0.12 && 0.5 + 0.12 < prob) { mean[bin1] = bin0 / (double)NDIV; }
            if(prob > 0.25 && probOld < 0.25) sigma[bin1] = bin0 / (double)NDIV;
            if(prob > 0.75 && probOld < 0.75)
                sigma[bin1] = std::fmax(((bin0 - 0.5) / (double)NDIV - sigma[bin1]) / 2.0, 0.0);
            if(probOld < 0.25 && 0.75 < prob) sigma[bin1] = -1.0 / (double)NDIV;
        }
        if(meanNorm > 0) mean[bin1] /= meanNorm;
        if(isnan(mean[bin1])) sigma[bin1] = NAN;
    }
 
    return {mean, sigma, DOS};
}

OverlapSqVsEnergy() [2/4]

template std::tuple< std::vector< double >, std::vector< double >, std::vector< double > > OverlapSqVsEnergy	(	Integer_t const	NDIV,
		Integer_t const	dim,
		std::vector< double > const &	Energy1,
		std::vector< double > const &	EnergyRange2,
		matrix< Complex_t< double > > const &	OverlapSq
	)

OverlapSqVsEnergy() [3/4]

template std::tuple< std::vector< double >, std::vector< double >, std::vector< double > > OverlapSqVsEnergy	(	Integer_t const	NDIV,
		Integer_t const	dim,
		std::vector< double > const &	Energy1,
		std::vector< double > const &	EnergyRange2,
		matrix< Complex_t< float > > const &	OverlapSq
	)

OverlapSqVsEnergy() [4/4]

template std::tuple< std::vector< double >, std::vector< double >, std::vector< double > > OverlapSqVsEnergy	(	Integer_t const	NDIV,
		Integer_t const	dim,
		std::vector< double > const &	Energy1,
		std::vector< double > const &	EnergyRange2,
		matrix< double > const &	OverlapSq
	)

SpectralRange()

double SpectralRange	(	double &	OpMin,
		Integer_t const	dim,
		matrix< Complex_t< double > > &	Operator
	)

                                                                                              {
    std::vector<double> Eigenvalue(dim);
    EigenValues(Eigenvalue, dim, Operator);
    OpMin = Eigenvalue[0];
    return Eigenvalue[dim - 1] - Eigenvalue[0];
}