ABACUS develop
Atomic-orbital Based Ab-initio Computation at UStc
Loading...
Searching...
No Matches
Protected Types | Protected Member Functions | Protected Attributes | List of all members
TestModuleHsolverMathKernel Class Reference
Inheritance diagram for TestModuleHsolverMathKernel:
Collaboration diagram for TestModuleHsolverMathKernel:

Protected Types

using zdot_real_cpu_op = ModuleBase::dot_real_op< std::complex< double >, base_device::DEVICE_CPU >
 
using zdot_real_gpu_op = ModuleBase::dot_real_op< std::complex< double >, base_device::DEVICE_GPU >
 
using resize_memory_op = base_device::memory::resize_memory_op< std::complex< double >, base_device::DEVICE_GPU >
 
using delete_memory_op = base_device::memory::delete_memory_op< std::complex< double >, base_device::DEVICE_GPU >
 
using synchronize_memory_op = base_device::memory::synchronize_memory_op< std::complex< double >, base_device::DEVICE_GPU, base_device::DEVICE_CPU >
 
using synchronize_memory_op_gpu = base_device::memory::synchronize_memory_op< std::complex< double >, base_device::DEVICE_CPU, base_device::DEVICE_GPU >
 
using resize_memory_op_double = base_device::memory::resize_memory_op< double, base_device::DEVICE_GPU >
 
using delete_memory_op_double = base_device::memory::delete_memory_op< double, base_device::DEVICE_GPU >
 
using synchronize_memory_op_double = base_device::memory::synchronize_memory_op< double, base_device::DEVICE_GPU, base_device::DEVICE_CPU >
 
using vector_mul_real_op_cpu = ModuleBase::vector_mul_real_op< std::complex< double >, base_device::DEVICE_CPU >
 
using vector_mul_vector_op_cpu = ModuleBase::vector_mul_vector_op< std::complex< double >, base_device::DEVICE_CPU >
 
using vector_div_vector_op_cpu = ModuleBase::vector_div_vector_op< std::complex< double >, base_device::DEVICE_CPU >
 
using vector_add_vector_op_cpu = ModuleBase::vector_add_vector_op< std::complex< double >, base_device::DEVICE_CPU >
 
using axpy_op_cpu = ModuleBase::axpy_op< std::complex< double >, base_device::DEVICE_CPU >
 
using scal_op_cpu = ModuleBase::scal_op< double, base_device::DEVICE_CPU >
 
using gemv_op_cpu = ModuleBase::gemv_op< std::complex< double >, base_device::DEVICE_CPU >
 
using vector_mul_real_op_gpu = ModuleBase::vector_mul_real_op< std::complex< double >, base_device::DEVICE_GPU >
 
using vector_mul_vector_op_gpu = ModuleBase::vector_mul_vector_op< std::complex< double >, base_device::DEVICE_GPU >
 
using vector_div_vector_op_gpu = ModuleBase::vector_div_vector_op< std::complex< double >, base_device::DEVICE_GPU >
 
using vector_add_vector_op_gpu = ModuleBase::vector_add_vector_op< std::complex< double >, base_device::DEVICE_GPU >
 
using axpy_op_gpu = ModuleBase::axpy_op< std::complex< double >, base_device::DEVICE_GPU >
 
using scal_op_gpu = ModuleBase::scal_op< double, base_device::DEVICE_GPU >
 
using gemv_op_gpu = ModuleBase::gemv_op< std::complex< double >, base_device::DEVICE_GPU >
 

Protected Member Functions

void SetUp () override
 
void TearDown () override
 

Protected Attributes

std::vector< std::complex< double > > psi_L
 
std::vector< std::complex< double > > psi_R
 
const int dim = psi_L.size()
 
const double expected_result = -5.0016151713691288
 
const base_device::DEVICE_CPU * cpu_ctx = {}
 
const base_device::DEVICE_GPU * gpu_ctx = {}
 
std::vector< std::complex< double > > L
 
std::vector< std::complex< double > > R
 
const std::vector< std::complex< double > > input = L
 
const double constant = 5.5
 
const std::vector< std::complex< double > > output_vector_mul_real_op
 
const std::vector< double > input_double
 
const std::vector< std::complex< double > > output_vector_mul_vector_op
 
const std::vector< std::complex< double > > output_vector_div_vector_op
 
const double constant1 = 6.6
 
const double constant2 = 4.4
 
const std::vector< std::complex< double > > input1 = L
 
const std::vector< std::complex< double > > input2 = R
 
const std::vector< std::complex< double > > output_vector_add_vector_op
 
const std::complex< double > alpha_axpy {-1.5, -2.5}
 
const std::vector< std::complex< double > > X_axpy = L
 
std::vector< std::complex< double > > Y_axpy = R
 
const std::vector< std::complex< double > > output_axpy_op
 
const std::complex< double > alpha_scal {-1.5, -2.5}
 
std::vector< std::complex< double > > X_scal = L
 
const std::vector< std::complex< double > > output_scal_op
 
const std::vector< std::complex< double > > A_gemv
 
const std::vector< std::complex< double > > X_gemv
 
std::vector< std::complex< double > > Y_gemv
 
std::vector< std::complex< double > > Y_test_gemv
 

Member Typedef Documentation

◆ axpy_op_cpu

using TestModuleHsolverMathKernel::axpy_op_cpu = ModuleBase::axpy_op<std::complex<double>, base_device::DEVICE_CPU>
protected

◆ axpy_op_gpu

using TestModuleHsolverMathKernel::axpy_op_gpu = ModuleBase::axpy_op<std::complex<double>, base_device::DEVICE_GPU>
protected

◆ delete_memory_op

using TestModuleHsolverMathKernel::delete_memory_op = base_device::memory::delete_memory_op<std::complex<double>, base_device::DEVICE_GPU>
protected

◆ delete_memory_op_double

using TestModuleHsolverMathKernel::delete_memory_op_double = base_device::memory::delete_memory_op<double, base_device::DEVICE_GPU>
protected

◆ gemv_op_cpu

using TestModuleHsolverMathKernel::gemv_op_cpu = ModuleBase::gemv_op<std::complex<double>, base_device::DEVICE_CPU>
protected

◆ gemv_op_gpu

using TestModuleHsolverMathKernel::gemv_op_gpu = ModuleBase::gemv_op<std::complex<double>, base_device::DEVICE_GPU>
protected

◆ resize_memory_op

using TestModuleHsolverMathKernel::resize_memory_op = base_device::memory::resize_memory_op<std::complex<double>, base_device::DEVICE_GPU>
protected

◆ resize_memory_op_double

using TestModuleHsolverMathKernel::resize_memory_op_double = base_device::memory::resize_memory_op<double, base_device::DEVICE_GPU>
protected

◆ scal_op_cpu

using TestModuleHsolverMathKernel::scal_op_cpu = ModuleBase::scal_op<double, base_device::DEVICE_CPU>
protected

◆ scal_op_gpu

using TestModuleHsolverMathKernel::scal_op_gpu = ModuleBase::scal_op<double, base_device::DEVICE_GPU>
protected

◆ synchronize_memory_op

using TestModuleHsolverMathKernel::synchronize_memory_op = base_device::memory:: synchronize_memory_op<std::complex<double>, base_device::DEVICE_GPU, base_device::DEVICE_CPU>
protected

◆ synchronize_memory_op_double

using TestModuleHsolverMathKernel::synchronize_memory_op_double = base_device::memory::synchronize_memory_op<double, base_device::DEVICE_GPU, base_device::DEVICE_CPU>
protected

◆ synchronize_memory_op_gpu

using TestModuleHsolverMathKernel::synchronize_memory_op_gpu = base_device::memory:: synchronize_memory_op<std::complex<double>, base_device::DEVICE_CPU, base_device::DEVICE_GPU>
protected

◆ vector_add_vector_op_cpu

using TestModuleHsolverMathKernel::vector_add_vector_op_cpu = ModuleBase::vector_add_vector_op<std::complex<double>, base_device::DEVICE_CPU>
protected

◆ vector_add_vector_op_gpu

using TestModuleHsolverMathKernel::vector_add_vector_op_gpu = ModuleBase::vector_add_vector_op<std::complex<double>, base_device::DEVICE_GPU>
protected

◆ vector_div_vector_op_cpu

using TestModuleHsolverMathKernel::vector_div_vector_op_cpu = ModuleBase::vector_div_vector_op<std::complex<double>, base_device::DEVICE_CPU>
protected

◆ vector_div_vector_op_gpu

using TestModuleHsolverMathKernel::vector_div_vector_op_gpu = ModuleBase::vector_div_vector_op<std::complex<double>, base_device::DEVICE_GPU>
protected

◆ vector_mul_real_op_cpu

using TestModuleHsolverMathKernel::vector_mul_real_op_cpu = ModuleBase::vector_mul_real_op<std::complex<double>, base_device::DEVICE_CPU>
protected

◆ vector_mul_real_op_gpu

using TestModuleHsolverMathKernel::vector_mul_real_op_gpu = ModuleBase::vector_mul_real_op<std::complex<double>, base_device::DEVICE_GPU>
protected

◆ vector_mul_vector_op_cpu

using TestModuleHsolverMathKernel::vector_mul_vector_op_cpu = ModuleBase::vector_mul_vector_op<std::complex<double>, base_device::DEVICE_CPU>
protected

◆ vector_mul_vector_op_gpu

using TestModuleHsolverMathKernel::vector_mul_vector_op_gpu = ModuleBase::vector_mul_vector_op<std::complex<double>, base_device::DEVICE_GPU>
protected

◆ zdot_real_cpu_op

using TestModuleHsolverMathKernel::zdot_real_cpu_op = ModuleBase::dot_real_op<std::complex<double>, base_device::DEVICE_CPU>
protected

◆ zdot_real_gpu_op

using TestModuleHsolverMathKernel::zdot_real_gpu_op = ModuleBase::dot_real_op<std::complex<double>, base_device::DEVICE_GPU>
protected

Member Function Documentation

◆ SetUp()

void TestModuleHsolverMathKernel::SetUp ( )
inlineoverrideprotected

◆ TearDown()

void TestModuleHsolverMathKernel::TearDown ( )
inlineoverrideprotected

Member Data Documentation

◆ A_gemv

const std::vector<std::complex<double> > TestModuleHsolverMathKernel::A_gemv
protected
Initial value:
= {
{-0.87403307, 2.74844882},
{4.38946833, 4.90517834},
{-11.33678411, -4.63461167},
{3.14637745, 8.26155093},
{1.47152165, -2.17179400},
{4.29982696, -8.23346099}}

◆ alpha_axpy

const std::complex<double> TestModuleHsolverMathKernel::alpha_axpy {-1.5, -2.5}
protected

◆ alpha_scal

const std::complex<double> TestModuleHsolverMathKernel::alpha_scal {-1.5, -2.5}
protected

◆ constant

const double TestModuleHsolverMathKernel::constant = 5.5
protected

◆ constant1

const double TestModuleHsolverMathKernel::constant1 = 6.6
protected

◆ constant2

const double TestModuleHsolverMathKernel::constant2 = 4.4
protected

◆ cpu_ctx

const base_device::DEVICE_CPU* TestModuleHsolverMathKernel::cpu_ctx = {}
protected

◆ dim

const int TestModuleHsolverMathKernel::dim = psi_L.size()
protected

◆ expected_result

const double TestModuleHsolverMathKernel::expected_result = -5.0016151713691288
protected

◆ gpu_ctx

const base_device::DEVICE_GPU* TestModuleHsolverMathKernel::gpu_ctx = {}
protected

◆ input

const std::vector<std::complex<double> > TestModuleHsolverMathKernel::input = L
protected

◆ input1

const std::vector<std::complex<double> > TestModuleHsolverMathKernel::input1 = L
protected

◆ input2

const std::vector<std::complex<double> > TestModuleHsolverMathKernel::input2 = R
protected

◆ input_double

const std::vector<double> TestModuleHsolverMathKernel::input_double
protected
Initial value:
= {
-0.65412617,
-0.74208893,
-2.21731157,
0.42540039,
3.36373004,
-2.51647562,
-2.985111,
-0.53251562,
0.37908265,
0.81605825,
1.66281318,
2.71761869,
}

◆ L

std::vector<std::complex<double> > TestModuleHsolverMathKernel::L
protected
Initial value:
= {{-0.65412617, -0.74208893},
{-2.21731157, 0.42540039},
{3.36373004, -2.51647562},
{-2.985111, -0.53251562},
{0.37908265, 0.81605825},
{1.66281318, 2.71761869},
{2.2010268, 0.65498149},
{1.51153638, 0.71501482},
{0.53546578, 1.4564317},
{-2.36701143, 1.23009056},
{3.41302551, -2.3175205},
{-0.27628221, -1.35701656}}

◆ output_axpy_op

const std::vector<std::complex<double> > TestModuleHsolverMathKernel::output_axpy_op
protected
Initial value:
= {{-1.04187063, 2.57843137},
{4.36025552, 5.18794423},
{-11.42394822, -4.75054595},
{6.50906977, 8.24708166},
{1.46770822, -2.33007099},
{4.53333119, -8.23539294},
{-1.41856581, -5.83818462},
{1.10278588, -2.14220619},
{2.67173827, -3.46052805},
{8.79651547, 4.55949747},
{-9.50076036, -4.51100042},
{-3.10745172, 2.72118808}}

◆ output_scal_op

const std::vector<std::complex<double> > TestModuleHsolverMathKernel::output_scal_op
protected
Initial value:
= {{-0.87403307, 2.74844882},
{4.38946833, 4.90517834},
{-11.33678411, -4.63461167},
{3.14637745, 8.26155093},
{1.47152165, -2.17179400},
{4.29982696, -8.23346099},
{-1.66408648, -6.48503924},
{-0.47976752, -4.85136318},
{2.83788058, -3.52331200},
{6.62574354, 4.07239273},
{-10.91333952, -5.05628302},
{-2.97811808, 2.72623036}}

◆ output_vector_add_vector_op

const std::vector<std::complex<double> > TestModuleHsolverMathKernel::output_vector_add_vector_op
protected
Initial value:
= {{-5.05571797, -5.64586374},
{-14.76279273, 4.05181248},
{21.81709620, -17.11884992},
{-4.90588639, -3.57826786},
{2.48516640, 4.68956570},
{12.00198564, 17.92778274},
{15.60706781, 7.16903816},
{16.93937507, 16.63938857},
{2.80304798, 9.88869860},
{-6.07087895, 10.26185851},
{28.74131667, -12.89639182},
{-2.39253058, -8.97849535}}

◆ output_vector_div_vector_op

const std::vector<std::complex<double> > TestModuleHsolverMathKernel::output_vector_div_vector_op
protected
Initial value:
= {{1.00000000, 1.13447369},
{2.98793242, -0.57324718},
{-1.51703084, 1.13492197},
{-7.01717974, -1.25179862},
{0.11269711, 0.24260516},
{-0.66077063, -1.07993047},
{-0.73733499, -0.21941613},
{-2.83848271, -1.34271145},
{1.41253043, 3.84198987},
{-2.90054225, 1.50735632},
{2.05256102, -1.39373474},
{-0.10166335, -0.49934031}}

◆ output_vector_mul_real_op

const std::vector<std::complex<double> > TestModuleHsolverMathKernel::output_vector_mul_real_op
protected
Initial value:
= {{-0.11893203, -0.13492526},
{-0.40314756, 0.07734553},
{0.61158728, -0.45754102},
{-0.54274745, -0.09682102},
{0.06892412, 0.14837423},
{0.30232967, 0.49411249},
{0.40018669, 0.11908754},
{0.27482480, 0.13000269},
{0.09735741, 0.26480576},
{-0.43036571, 0.22365283},
{0.62055009, -0.42136736},
{-0.05023313, -0.24673028}}

◆ output_vector_mul_vector_op

const std::vector<std::complex<double> > TestModuleHsolverMathKernel::output_vector_mul_vector_op
protected
Initial value:
= {{0.42788105, 0.48541979},
{1.64544237, -0.31568492},
{-7.45843754, 5.57981051},
{-1.26986738, -0.22653235},
{1.27513170, 2.74499965},
{-4.18442883, -6.83882118},
{-6.57030931, -1.95519245},
{-0.80491673, -0.38075656},
{0.20298579, 0.55210799},
{-1.93161921, 1.00382555},
{5.67522380, -3.85360363},
{-0.75082970, -3.68785357}}

◆ psi_L

std::vector<std::complex<double> > TestModuleHsolverMathKernel::psi_L
protected
Initial value:
= {{-0.65412617, -0.74208893},
{-2.21731157, 0.42540039},
{3.36373004, -2.51647562},
{-2.985111, -0.53251562},
{0.37908265, 0.81605825},
{1.66281318, 2.71761869},
{2.2010268, 0.65498149},
{1.51153638, 0.71501482},
{0.53546578, 1.4564317},
{-2.36701143, 1.23009056},
{3.41302551, -2.3175205},
{-0.27628221, -1.35701656}}

◆ psi_R

std::vector<std::complex<double> > TestModuleHsolverMathKernel::psi_R
protected
Initial value:
= {{-1.67837557e-01, -1.70017454e-01},
{-2.92128115e-02, 2.82765887e-01},
{-8.71641062e-02, -1.15934278e-01},
{3.36269232e+00, -1.44692661e-02},
{-3.81342874e-03, -1.58276988e-01},
{2.33504238e-01, -1.93195840e-03},
{2.45520665e-01, 6.46854620e-01},
{1.58255340e+00, 2.70915699e+00},
{-1.66142311e-01, 6.27839507e-02},
{2.17077193e+00, 4.87104731e-01},
{1.41257916e+00, 5.45282609e-01},
{-1.29333636e-01, -5.04228492e-03}}

◆ R

std::vector<std::complex<double> > TestModuleHsolverMathKernel::R
protected
Initial value:
= {{-1.67837557e-01, -1.70017454e-01},
{-2.92128115e-02, 2.82765887e-01},
{-8.71641062e-02, -1.15934278e-01},
{3.36269232e+00, -1.44692661e-02},
{-3.81342874e-03, -1.58276988e-01},
{2.33504238e-01, -1.93195840e-03},
{2.45520665e-01, 6.46854620e-01},
{1.58255340e+00, 2.70915699e+00},
{-1.66142311e-01, 6.27839507e-02},
{2.17077193e+00, 4.87104731e-01},
{1.41257916e+00, 5.45282609e-01},
{-1.29333636e-01, -5.04228492e-03}}

◆ X_axpy

const std::vector<std::complex<double> > TestModuleHsolverMathKernel::X_axpy = L
protected

◆ X_gemv

const std::vector<std::complex<double> > TestModuleHsolverMathKernel::X_gemv
protected
Initial value:
= {
{-0.87403307, 2.74844882},
{4.38946833, 4.90517834}}

◆ X_scal

std::vector<std::complex<double> > TestModuleHsolverMathKernel::X_scal = L
protected

◆ Y_axpy

std::vector<std::complex<double> > TestModuleHsolverMathKernel::Y_axpy = R
protected

◆ Y_gemv

std::vector<std::complex<double> > TestModuleHsolverMathKernel::Y_gemv
protected
Initial value:
= {
{1.47152165, -2.17179400},
{4.29982696, -8.23346099},
{3.14637745, 8.26155093}}

◆ Y_test_gemv

std::vector<std::complex<double> > TestModuleHsolverMathKernel::Y_test_gemv
protected
Initial value:
= {
{1.47152165, -2.17179400},
{4.29982696, -8.23346099},
{3.14637745, 8.26155093}}
The documentation for this class was generated from the following file:
Generated by doxygen 1.9.8