RandomMatrix_test.cpp File Reference

Functions
template<class Derived >
double	MeanLevelSpacingsRatio (Eigen::DenseBase< Derived > const &eigVals)
int	main (int argc, char **argv)

Function Documentation

main()

int main	(	int	argc,
		char **	argv
	)

                                {
    if(argc != 3) {
        std::cerr << "Usage: 1.(This) 2.(dim) 3.(seed)\n"
                  << "argc = " << argc << std::endl;
        std::exit(EXIT_FAILURE);
    }
    int const dim  = std::atoi(argv[1]);
    int const seed = std::atoi(argv[2]);
    std::cout << "Input: dim = " << dim << std::endl;
 
    {
        // GUE
        HilbertSpace<>                                     hSpace(dim);
        OperatorSpace<Complex_t<double>>                   opSpace(hSpace);
        GaussianRandomMatrixGenerator< decltype(opSpace) > GRME(opSpace, seed);
 
        double                            generationTime = getETtime();
        Eigen::MatrixX<Complex_t<double>> mat(GRME());
        generationTime = getETtime() - generationTime;
        std::cout << "generationTime = " << generationTime << " (sec)" << std::endl;
 
        double                                         processTime = getETtime();
        Eigen::SelfAdjointEigenSolver< decltype(mat) > solver(mat, Eigen::EigenvaluesOnly);
        std::cout << "Mean level spacings ratio = " << MeanLevelSpacingsRatio(solver.eigenvalues())
                  << std::endl;
        processTime = getETtime() - processTime;
        std::cout << "processTime = " << processTime << " (sec)" << std::endl;
    }
    std::cout << std::endl;
 
    int L = 6;
    {
        std::cout << "L = " << L << ", m = All" << std::endl;
        ManyBodySpinSpace                        mbHSpace(L, 2);
        ManyBodyOperatorSpace<Complex_t<double>> mbOpSpace(mbHSpace);
        std::cout << "mbHSpace.dim() = " << mbHSpace.dim() << "\n"
                  << "mbOpSpace.dim() = " << mbOpSpace.dim() << std::endl;
        GaussianRandomMatrixGenerator< decltype(mbOpSpace) > GRME(mbOpSpace, seed);
 
        double                            generationTime = getETtime();
        Eigen::MatrixX<Complex_t<double>> mat(GRME());
        generationTime = getETtime() - generationTime;
        std::cout << "generationTime = " << generationTime << " (sec)" << std::endl;
 
        double                                         processTime = getETtime();
        Eigen::SelfAdjointEigenSolver< decltype(mat) > solver(mat, Eigen::EigenvaluesOnly);
        std::cout << "Mean level spacings ratio = " << MeanLevelSpacingsRatio(solver.eigenvalues())
                  << std::endl;
        processTime = getETtime() - processTime;
        std::cout << "processTime = " << processTime << " (sec)" << std::endl;
    }
    std::cout << std::endl;
 
    {
        for(int m = 1; m <= L; ++m) {
            std::cout << "L = " << L << ", m = " << m << std::endl;
 
            ManyBodySpinSpace                     mbHSpace(L, 2);
            mBodyOperatorSpace<Complex_t<double>> mbOpSpace(m, mbHSpace);
            std::cout << "mbHSpace.dim() = " << mbHSpace.dim() << "\n"
                      << "mbOpSpace.dim() = " << mbOpSpace.dim() << std::endl;
            GaussianRandomMatrixGenerator< decltype(mbOpSpace) > GRME(mbOpSpace, seed);
 
            double                            generationTime = getETtime();
            Eigen::MatrixX<Complex_t<double>> mat(GRME());
            generationTime = getETtime() - generationTime;
            std::cout << "generationTime = " << generationTime << " (sec)" << std::endl;
 
            double                                         processTime = getETtime();
            Eigen::SelfAdjointEigenSolver< decltype(mat) > solver(mat, Eigen::EigenvaluesOnly);
            std::cout << "Mean level spacings ratio = "
                      << MeanLevelSpacingsRatio(solver.eigenvalues()) << std::endl;
            processTime = getETtime() - processTime;
            std::cout << "processTime = " << processTime << " (sec)\n" << std::endl;
        }
    }
 
    return EXIT_SUCCESS;
}

MeanLevelSpacingsRatio()

template<class Derived >

double MeanLevelSpacingsRatio

(

Eigen::DenseBase< Derived > const &

eigVals

)

                                                                      {
    double meanLSR = 0;
    for(int j = 1; j < eigVals.size() - 1; ++j) {
        double interval1 = eigVals(j) - eigVals(j - 1);
        double interval2 = eigVals(j + 1) - eigVals(j);
        meanLSR += (interval1 > interval2 ? interval2 / interval1 : interval1 / interval2);
    }
    meanLSR /= eigVals.size();
    return meanLSR;
}