ScalarType opencl_2d_fft_1arg(std::vector<ScalarType>& in,
std::vector<ScalarType>& out,
unsigned int row, unsigned int col, unsigned int /*batch_size*/)
{
viennacl::matrix<ScalarType> input(row, 2 * col);
std::vector<ScalarType> res(in.size());
viennacl::fast_copy(&in[0], &in[0] + in.size(), input);
//std::cout << input << "\n";
viennacl::inplace_fft(input);
//std::cout << input << "\n";
viennacl::backend::finish();
viennacl::fast_copy(input, &res[0]);
return diff_max(res, out);
}
ScalarType opencl_bluestein(std::vector<ScalarType>& in,
std::vector<ScalarType>& out,
unsigned int /*row*/, unsigned int /*col*/, unsigned int batch_size)
{
viennacl::vector<ScalarType> input(in.size());
viennacl::vector<ScalarType> output(in.size());
std::vector<ScalarType> res(in.size());
viennacl::fast_copy(in, input);
viennacl::detail::fft::bluestein(input, output, batch_size);
viennacl::backend::finish();
viennacl::fast_copy(output, res);
return diff_max(res, out);
}
ScalarType opencl_radix2(std::vector<ScalarType>& in,
std::vector<ScalarType>& out,
unsigned int /*row*/, unsigned int /*col*/, unsigned int batch_num)
{
viennacl::vector<ScalarType> input(in.size());
viennacl::vector<ScalarType> output(in.size());
std::vector<ScalarType> res(in.size());
viennacl::fast_copy(in, input);
unsigned int size = (static_cast<unsigned int>(input.size()) >> 1) / batch_num;
viennacl::detail::fft::radix2<ScalarType>(input.handle().opencl_handle(), size, size, batch_num);
viennacl::backend::finish();
viennacl::fast_copy(input, res);
return diff_max(res, out);
}
ScalarType opencl_convolve(std::vector<ScalarType>& in1,
std::vector<ScalarType>& in2,
unsigned int /*row*/, unsigned int /*col*/, unsigned int /*batch_size*/)
{
//if(in1.size() > 2048) return -1;
viennacl::vector<ScalarType> input1(in1.size());
viennacl::vector<ScalarType> input2(in2.size());
viennacl::vector<ScalarType> output(in1.size());
viennacl::fast_copy(in1, input1);
viennacl::fast_copy(in2, input2);
viennacl::linalg::convolve(input1, input2, output);
viennacl::backend::finish();
std::vector<ScalarType> res(in1.size());
viennacl::fast_copy(output, res);
std::vector<ScalarType> ref(in1.size());
convolve_ref(in1, in2, ref);
return diff_max(res, ref);
}
int hankel_test(ScalarType epsilon)
{
std::size_t HANKEL_SIZE = 7;
viennacl::hankel_matrix<ScalarType> vcl_hankel1(HANKEL_SIZE, HANKEL_SIZE);
viennacl::hankel_matrix<ScalarType> vcl_hankel2(HANKEL_SIZE, HANKEL_SIZE);
viennacl::vector<ScalarType> vcl_input(HANKEL_SIZE);
viennacl::vector<ScalarType> vcl_result(HANKEL_SIZE);
std::vector<ScalarType> input_ref(HANKEL_SIZE);
std::vector<ScalarType> result_ref(HANKEL_SIZE);
dense_matrix<ScalarType> m1(vcl_hankel1.size1(), vcl_hankel1.size2());
dense_matrix<ScalarType> m2(m1.size1(), m1.size2());
for (std::size_t i = 0; i < m1.size1(); i++)
for (std::size_t j = 0; j < m1.size2(); j++)
{
m1(i,j) = static_cast<ScalarType>((i + j) % (2 * m1.size1()));
m2(i,j) = m1(i,j) * m1(i,j) + ScalarType(1);
}
for (std::size_t i = 0; i < input_ref.size(); i++)
input_ref[i] = ScalarType(i);
// Copy to ViennaCL
viennacl::copy(m1, vcl_hankel1);
viennacl::copy(m2, vcl_hankel2);
viennacl::copy(input_ref, vcl_input);
//
// Matrix-Vector product:
//
vcl_result = viennacl::linalg::prod(vcl_hankel1, vcl_input);
for (std::size_t i = 0; i < m1.size1(); i++) //reference calculation
{
ScalarType entry = 0;
for (std::size_t j = 0; j < m1.size2(); j++)
entry += m1(i,j) * input_ref[j];
result_ref[i] = entry;
}
viennacl::copy(vcl_result, input_ref);
std::cout << "Matrix-Vector Product: " << diff_max(input_ref, result_ref);
if (diff_max(input_ref, result_ref) < epsilon)
std::cout << " [OK]" << std::endl;
else
{
for (std::size_t i=0; i<input_ref.size(); ++i)
std::cout << "Should: " << result_ref[i] << ", is: " << input_ref[i] << std::endl;
std::cout << " [FAILED]" << std::endl;
return EXIT_FAILURE;
}
//
// Matrix addition:
//
vcl_hankel1 += vcl_hankel2;
for (std::size_t i = 0; i < m1.size1(); i++) //reference calculation
for (std::size_t j = 0; j < m1.size2(); j++)
m1(i,j) += m2(i,j);
viennacl::copy(vcl_hankel1, m2);
std::cout << "Matrix Addition: " << diff(m1, m2);
if (diff(m1, m2) < epsilon)
std::cout << " [OK]" << std::endl;
else
{
std::cout << " [FAILED]" << std::endl;
return EXIT_FAILURE;
}
//
// Per-Element access:
//
vcl_hankel1(4,2) = 42;
for (std::size_t i = 0; i < m1.size1(); i++) //reference calculation
for (std::size_t j = 0; j < m1.size2(); j++)
{
if ((i + j) % (2*m1.size1()) == 6)
m1(i, j) = 42;
}
viennacl::copy(vcl_hankel1, m2);
std::cout << "Element manipulation: " << diff(m1, m2);
if (diff(m1, m2) < epsilon)
std::cout << " [OK]" << std::endl;
else
{
std::cout << " [FAILED]" << std::endl;
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
int vandermonde_test(ScalarType epsilon)
{
std::size_t VANDERMONDE_SIZE = 61;
viennacl::vandermonde_matrix<ScalarType> vcl_vandermonde1(VANDERMONDE_SIZE, VANDERMONDE_SIZE);
viennacl::vandermonde_matrix<ScalarType> vcl_vandermonde2(VANDERMONDE_SIZE, VANDERMONDE_SIZE);
viennacl::vector<ScalarType> vcl_input(VANDERMONDE_SIZE);
viennacl::vector<ScalarType> vcl_result(VANDERMONDE_SIZE);
std::vector<ScalarType> input_ref(VANDERMONDE_SIZE);
std::vector<ScalarType> result_ref(VANDERMONDE_SIZE);
dense_matrix<ScalarType> m1(vcl_vandermonde1.size1(), vcl_vandermonde1.size2());
dense_matrix<ScalarType> m2(m1.size1(), m1.size2());
for (std::size_t i = 0; i < m1.size1(); i++)
for (std::size_t j = 0; j < m1.size2(); j++)
{
m1(i,j) = std::pow(ScalarType(1.0 + i/1000.0), ScalarType(j));
m2(i,j) = std::pow(ScalarType(1.0 - i/2000.0), ScalarType(j));
}
for (std::size_t i = 0; i < input_ref.size(); i++)
input_ref[i] = ScalarType(i);
// Copy to ViennaCL
viennacl::copy(m1, vcl_vandermonde1);
viennacl::copy(m2, vcl_vandermonde2);
viennacl::copy(input_ref, vcl_input);
//
// Matrix-Vector product:
//
vcl_result = viennacl::linalg::prod(vcl_vandermonde1, vcl_input);
for (std::size_t i = 0; i < m1.size1(); i++) //reference calculation
{
ScalarType entry = 0;
for (std::size_t j = 0; j < m1.size2(); j++)
entry += m1(i,j) * input_ref[j];
result_ref[i] = entry;
}
viennacl::copy(vcl_result, input_ref);
std::cout << "Matrix-Vector Product: " << diff_max(input_ref, result_ref);
if (diff_max(input_ref, result_ref) < epsilon)
std::cout << " [OK]" << std::endl;
else
{
for (std::size_t i=0; i<input_ref.size(); ++i)
std::cout << "Should: " << result_ref[i] << ", is: " << input_ref[i] << std::endl;
std::cout << " [FAILED]" << std::endl;
return EXIT_FAILURE;
}
//
// Note: Matrix addition does not make sense for a Vandermonde matrix
//
//
// Per-Element access:
//
vcl_vandermonde1(4) = static_cast<ScalarType>(1.0001);
for (std::size_t j = 0; j < m1.size2(); j++)
{
m1(4, j) = std::pow(ScalarType(1.0001), ScalarType(j));
}
viennacl::copy(vcl_vandermonde1, m2);
std::cout << "Element manipulation: " << diff(m1, m2);
if (diff(m1, m2) < epsilon)
std::cout << " [OK]" << std::endl;
else
{
std::cout << " [FAILED]" << std::endl;
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
int toeplitz_test(ScalarType epsilon)
{
std::size_t TOEPLITZ_SIZE = 47;
viennacl::toeplitz_matrix<ScalarType> vcl_toeplitz1(TOEPLITZ_SIZE, TOEPLITZ_SIZE);
viennacl::toeplitz_matrix<ScalarType> vcl_toeplitz2(TOEPLITZ_SIZE, TOEPLITZ_SIZE);
viennacl::vector<ScalarType> vcl_input(TOEPLITZ_SIZE);
viennacl::vector<ScalarType> vcl_result(TOEPLITZ_SIZE);
std::vector<ScalarType> input_ref(TOEPLITZ_SIZE);
std::vector<ScalarType> result_ref(TOEPLITZ_SIZE);
dense_matrix<ScalarType> m1(TOEPLITZ_SIZE, TOEPLITZ_SIZE);
dense_matrix<ScalarType> m2(TOEPLITZ_SIZE, TOEPLITZ_SIZE);
for (std::size_t i = 0; i < TOEPLITZ_SIZE; i++)
for (std::size_t j = 0; j < TOEPLITZ_SIZE; j++)
{
m1(i,j) = static_cast<ScalarType>(i) - static_cast<ScalarType>(j);
m2(i,j) = m1(i,j) * m1(i,j) + ScalarType(1);
}
for (std::size_t i = 0; i < TOEPLITZ_SIZE; i++)
input_ref[i] = ScalarType(i);
// Copy to ViennaCL
viennacl::copy(m1, vcl_toeplitz1);
viennacl::copy(m2, vcl_toeplitz2);
viennacl::copy(input_ref, vcl_input);
//
// Matrix-Vector product:
//
vcl_result = viennacl::linalg::prod(vcl_toeplitz1, vcl_input);
for (std::size_t i = 0; i < m1.size1(); i++) //reference calculation
{
ScalarType entry = 0;
for (std::size_t j = 0; j < m1.size2(); j++)
entry += m1(i,j) * input_ref[j];
result_ref[i] = entry;
}
viennacl::copy(vcl_result, input_ref);
std::cout << "Matrix-Vector Product: " << diff_max(input_ref, result_ref);
if (diff_max(input_ref, result_ref) < epsilon)
std::cout << " [OK]" << std::endl;
else
{
for (std::size_t i=0; i<input_ref.size(); ++i)
std::cout << "Should: " << result_ref[i] << ", is: " << input_ref[i] << std::endl;
std::cout << " [FAILED]" << std::endl;
return EXIT_FAILURE;
}
//
// Matrix addition:
//
vcl_toeplitz1 += vcl_toeplitz2;
for (std::size_t i = 0; i < m1.size1(); i++) //reference calculation
for (std::size_t j = 0; j < m1.size2(); j++)
m1(i,j) += m2(i,j);
viennacl::copy(vcl_toeplitz1, m2);
std::cout << "Matrix Addition: " << diff(m1, m2);
if (diff(m1, m2) < epsilon)
std::cout << " [OK]" << std::endl;
else
{
std::cout << " [FAILED]" << std::endl;
return EXIT_FAILURE;
}
//
// Per-Element access:
//
vcl_toeplitz1(2,4) = 42;
for (std::size_t i=0; i<m1.size1(); ++i) //reference calculation
{
if (i + 2 < m1.size2())
m1(i, i+2) = 42;
}
viennacl::copy(vcl_toeplitz1, m2);
std::cout << "Element manipulation: " << diff(m1, m2);
if (diff(m1, m2) < epsilon)
std::cout << " [OK]" << std::endl;
else
{
std::cout << " [FAILED]" << std::endl;
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
