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; }