ObjectOnGPU_EigenMatrix_test.cu File Reference

Classes
class	MagmaController
class	Dummy

Functions
template<typename RealScalar >
double	MeanLevelSpasingsRatio (Eigen::VectorX< RealScalar > const &eigvecs)
int	main (int argc, char **argv)

Function Documentation

main()

int main	(	int	argc,
		char **	argv
	)

                                {
    if(argc != 3) {
        std::cerr << "Usage: 1.(This) 2.(rows) 3.(cols)\n"
                  << "       argc=" << argc << std::endl;
        std::exit(EXIT_FAILURE);
    }
    int const rows = std::atoi(argv[1]);
    int const cols = std::atoi(argv[2]);
 
    std::mt19937                     mt;
    std::normal_distribution<double> Gaussian;
 
    MagmaController::getInstance();
    cuCHECK(cudaDeviceSetLimit(cudaLimitMallocHeapSize, size_t(16) * size_t(1024 * 1024 * 1024)));
 
    // Testing Default constructor
    {
        ObjectOnGPU< Eigen::MatrixXd > dMat(rows, cols);
        // std::cout << dMat << std::endl;
        std::cout << "Passed the test point 1.\n" << std::endl;
    }
    {
        Dummy dummy(rows, cols);
        std::cout << "Passed the test point 3.\n" << std::endl;
    }
 
    // Testing constructor from CPU matrix and Copy & Move constructors
    {
        using Scalar                = Complex_t<double>;
        Eigen::MatrixX<Scalar> hMat = Eigen::MatrixX<Scalar>::NullaryExpr(
            rows, cols, [&]() { return Complex_t<double>(Gaussian(mt), Gaussian(mt)); });
        ObjectOnGPU< Eigen::MatrixX<Scalar> > dMat1(hMat);
        // ObjectOnGPU< Eigen::MatrixX<Scalar> >      dMat2(dMat1); // Shoule give a compile-time error
        ObjectOnGPU< Eigen::MatrixX<Scalar> > dMat2(std::move(dMat1));
        std::cout << "Passed the test point 4 (Move).\n" << std::endl;
    }
 
    // Testing EigenSolver< ObjectOnGPU<Eigen::MatrixX<...>> >
    {
        using Scalar                = Complex_t<double>;
        Eigen::MatrixX<Scalar> hMat = Eigen::MatrixX<Scalar>::NullaryExpr(
            rows, cols, [&]() { return Complex_t<double>(Gaussian(mt), Gaussian(mt)); });
        ObjectOnGPU< Eigen::MatrixX<Scalar> > dMat(hMat);
 
        MatrixUtils::EigenSolver< decltype(dMat) > eigsolver(std::move(dMat));
        std::cout << "Level spasings ratio = " << MeanLevelSpasingsRatio(eigsolver.eigenvalues())
                  << std::endl;
        std::cout << "Passed the test point 5.\n" << std::endl;
    }
 
    {
        using Scalar                = Complex_t<double>;
        Eigen::MatrixX<Scalar> hMat = Eigen::MatrixX<Scalar>::NullaryExpr(
            rows, cols, [&]() { return Complex_t<double>(Gaussian(mt), Gaussian(mt)); });
        hMat = (hMat + hMat.adjoint().eval()) / 2.0;
        ObjectOnGPU< Eigen::MatrixX<Scalar> > dMat1(hMat);
 
        hMat = Eigen::MatrixX<Scalar>::NullaryExpr(
            rows, cols, [&]() { return Complex_t<double>(Gaussian(mt), Gaussian(mt)); });
        hMat = (hMat + hMat.adjoint().eval()) / 2.0;
        ObjectOnGPU< Eigen::MatrixX<Scalar> > dMat2(hMat);
 
        std::cout << dMat1 << std::endl;
        std::cout << dMat2 << std::endl;
        std::cout << "After multiplication\n" << dMat1 * dMat2 << std::endl;
        std::cout << "Passed the test point 5.\n" << std::endl;
    }
 
    return EXIT_SUCCESS;
}

MeanLevelSpasingsRatio()

template<typename RealScalar >

double MeanLevelSpasingsRatio

(

Eigen::VectorX< RealScalar > const &

eigvecs

)

                                                                       {
    if(eigvecs.size() <= 2) {
        std::cout << "Error: "
                  << "eigvecs.size() = " << eigvecs.size() << "should be larger than 2."
                  << std::endl;
        std::exit(EXIT_FAILURE);
    }
    double res = 0;
    for(auto j = 1; j < eigvecs.size() - 1; ++j) {
        double temp1 = eigvecs[j] - eigvecs[j - 1];
        double temp2 = eigvecs[j + 1] - eigvecs[j];
        res += (temp1 < temp2 ? temp1 / temp2 : temp2 / temp1);
    }
    res /= (eigvecs.size() - 2);
    return res;
}