int main(int argc, char *argv[]) {
int info;
int m = 6;
int n = 4;
if (argc > 2) {
m = boost::lexical_cast<int>(argv[1]);
n = boost::lexical_cast<int>(argv[2]);
}
std::cout << "m = " << m << "\nn = " << n << std::endl;
int k = std::min(m, n);
// generate random martix
matrix_t mat = matrix_t::Random(m, n);
std::cout << "Input random matrix A:\n" << mat << std::endl;
// singular value decomposition
matrix_t a = mat; // 'a' will be destroyed by dgesvd
vector_t s(k), superb(k);
matrix_t u(m, k), vt(k, n);
info = LAPACKE_zgesvd(LAPACK_COL_MAJOR, 'S', 'S', m, n, &a(0, 0), m, &s(0),
&u(0, 0), m, &vt(0, 0), k, &superb(0));
std::cout << "U:\n" << u << std::endl;
std::cout << "S:\n" << s << std::endl;
std::cout << "Vt:\n" << vt << std::endl;
// check correctness of SVD
matrix_t smat = matrix_t::Zero(k, k);
for (int i = 0; i < k; ++i) smat(i, i) = s(i);
matrix_t check = u * smat * vt;
std::cout << "U * S * Vt:\n" << check << std::endl;
std::cout << "| A - U * S * Vt | = " << (mat - check).norm() << std::endl;
}
void test_direct_trans()
{
const index_t m = M == 0 ? DM : M;
const index_t n = N == 0 ? DN : N;
// M x N ==> N x M
typedef typename mat_host<Tag1, double, M, N>::cmat_t cmat_t;
typedef typename mat_host<Tag2, double, N, M>::mat_t mat_t;
mat_host<Tag1, double, M, N> src(m, n);
mat_host<Tag2, double, N, M> dst(n, m);
src.fill_lin();
cmat_t smat = src.get_cmat();
mat_t dmat = dst.get_mat();
transpose(smat, dmat);
dense_matrix<double, N, M> rmat(n, m);
for (index_t i = 0; i < m; ++i)
{
for (index_t j = 0; j < n; ++j) rmat(j, i) = smat(i, j);
}
ASSERT_MAT_EQ(n, m, dmat, rmat);
// N x M ==> M x N
typedef typename mat_host<Tag1, double, N, M>::cmat_t cmat2_t;
typedef typename mat_host<Tag2, double, M, N>::mat_t mat2_t;
mat_host<Tag1, double, N, M> src2(n, m);
mat_host<Tag2, double, M, N> dst2(m, n);
src2.fill_lin();
cmat2_t smat2 = src2.get_cmat();
mat2_t dmat2 = dst2.get_mat();
transpose(smat2, dmat2);
dense_matrix<double, M, N> rmat2(m, n);
for (index_t i = 0; i < m; ++i)
{
for (index_t j = 0; j < n; ++j) rmat2(i, j) = smat2(j, i);
}
ASSERT_MAT_EQ(m, n, dmat2, rmat2);
}
static CRef<CGeneralScoreMatrix> s_ReadScoreMatrix(const string& filename)
{
CNcbiIfstream istr(filename.c_str());
BOOST_REQUIRE(istr);
vector<Int4> scores;
while (!istr.eof()) {
Int4 val;
istr >> val;
scores.push_back(val);
}
CRef<CGeneralScoreMatrix> smat(new CGeneralScoreMatrix(scores));
return smat;
}
Action::Status AbortAction::run() {
owner->start(this);
if (message.length() > 0) {
SendMessageActionTemplate smat(this->message.c_str(), owner);
Action *sma = smat.factory(owner);
(*sma)();
}
abort();
if (abort_fail) {
status = Failed;
error_str = strdup(message.c_str());
}
else
status = Complete;
owner->stop(this);
return status;
}
CPM_BENCH() {
CPM_TWO_PASS_NS_P(
pmp_policy,
"pmp_h(c=2) (s) [pmp][s]",
[](size_t d){ return std::make_tuple(smat(d, d), smat(d,d)); },
[](smat& a, smat& r){ r = etl::p_max_pool_h<2,2>(a); },
[](size_t d){ return 2 * d * d * 2 * 2; }
);
#ifdef ETL_EXTENDED_BENCH
CPM_TWO_PASS_NS_P(
pmp_policy_3,
"pmp_h_3(c=2) (s) [pmp][s]",
[](size_t d){ return std::make_tuple(smat3(50UL, d, d), smat3(50UL, d,d)); },
[](smat3& a, smat3& r){ r = etl::p_max_pool_h<2,2>(a); },
[](size_t d){ return 50 * 2 * d * d * 2 * 2; }
);
CPM_TWO_PASS_NS_P(
pmp_policy_3,
"pmp_h_4(c=2) (s) [pmp][s]",
[](size_t d){ return std::make_tuple(smat4(50UL, 50UL, d, d), smat4(50UL, 50UL, d,d)); },
[](smat4& a, smat4& r){ r = etl::p_max_pool_h<2,2>(a); },
[](size_t d){ return 50 * 50 * 2 * d * d * 2 * 2; }
);
CPM_TWO_PASS_NS_P(
pmp_policy,
"dyn_pmp_h(c=2) (s) [pmp][s]",
[](size_t d){ return std::make_tuple(smat(d, d), smat(d, d)); },
[](smat& a, smat& r){ r = etl::p_max_pool_h(a, 2, 2); },
[](size_t d){ return 2 * d * d * 2 * 2; }
);
#endif
CPM_TWO_PASS_NS_P(
pmp_policy,
"pmp_p(c=2) (s) [pmp][s]",
[](size_t d){ return std::make_tuple(smat(d, d), smat(d/2,d/2)); },
[](smat& a, smat& r){ r = etl::p_max_pool_p<2,2>(a); },
[](size_t d){ return 2 * d * d * 2 * 2; }
);
CPM_TWO_PASS_NS_P(
pmp_policy,
"pmp_h(c=4) (s) [pmp][s]",
[](size_t d){ return std::make_tuple(smat(d, d), smat(d,d)); },
[](smat& a, smat& r){ r = etl::p_max_pool_h<4,4>(a); },
[](size_t d){ return 2 * d * d * 4 * 4; }
);
CPM_TWO_PASS_NS_P(
pmp_policy,
"pmp_p(c=4) (s) [pmp][s]",
[](size_t d){ return std::make_tuple(smat(d, d), smat(d/4,d/4)); },
[](smat& a, smat& r){ r = etl::p_max_pool_p<4,4>(a); },
[](size_t d){ return 2 * d * d * 4 * 4; }
);
CPM_TWO_PASS_NS_P(
pmp_policy,
"pmp_h(c=2) (d) [pmp][s]",
[](size_t d){ return std::make_tuple(dmat(d, d), dmat(d,d)); },
[](dmat& a, dmat& r){ r = etl::p_max_pool_h<2,2>(a); },
[](size_t d){ return 2 * d * d * 2 * 2; }
);
CPM_TWO_PASS_NS_P(
pmp_policy,
"pmp_p(c=2) (d) [pmp][s]",
[](size_t d){ return std::make_tuple(dmat(d, d), dmat(d/2,d/2)); },
[](dmat& a, dmat& r){ r = etl::p_max_pool_p<2,2>(a); },
[](size_t d){ return 2 * d * d * 2 * 2; }
);
CPM_TWO_PASS_NS_P(
pmp_policy,
"pmp_h(c=4) (d) [pmp][s]",
[](size_t d){ return std::make_tuple(dmat(d, d), dmat(d,d)); },
[](dmat& a, dmat& r){ r = etl::p_max_pool_h<4,4>(a); },
[](size_t d){ return 2 * d * d * 4 * 4; }
);
CPM_TWO_PASS_NS_P(
pmp_policy,
"pmp_p(c=4) (d) [pmp][s]",
[](size_t d){ return std::make_tuple(dmat(d, d), dmat(d/4,d/4)); },
[](dmat& a, dmat& r){ r = etl::p_max_pool_p<4,4>(a); },
[](size_t d){ return 2 * d * d * 4 * 4; }
);
}
