typename std::common_type<typename M1::value_type, typename M2::value_type>::type
inner_product(const M1& A, const M2& B)
{
#ifdef UNROLL
auto s1 = A(0, 0) * B(0, 0);
auto s2 = A(1, 0) * B(1, 0);
auto s3 = A(2, 0) * B(2, 0);
auto s4 = A(3, 0) * B(3, 0);
for(std::size_t j=0; j < A.cols(); ++j)
for(std::size_t i=0; i < A.rows(); i+=4)
{
s1 += A(i,j) * B(i,j);
s2 += A(i+1,j) * B(i+1,j);
s3 += A(i+2,j) * B(i+2,j);
s4 += A(i+3,j) * B(i+3,j);
}
return s1 + s2 + s3 + s4;
#else
auto s = A(0, 0) * B(0, 0);
for(std::size_t j=0; j < A.cols(); ++j)
for(std::size_t i=0; i < A.rows(); ++i)
s += A(i,j) * B(i,j);
return s;
#endif
}
typename viennacl::enable_if< viennacl::is_any_dense_nonstructured_matrix<M1>::value
&& viennacl::is_any_dense_nonstructured_vector<V1>::value
>::type
inplace_solve(const M1 & mat,
V1 & vec,
SOLVERTAG)
{
assert( (mat.size1() == vec.size()) && bool("Size check failed in inplace_solve(): size1(A) != size(b)"));
assert( (mat.size2() == vec.size()) && bool("Size check failed in inplace_solve(): size2(A) != size(b)"));
switch (viennacl::traits::handle(mat).get_active_handle_id())
{
case viennacl::MAIN_MEMORY:
viennacl::linalg::host_based::inplace_solve(mat, vec, SOLVERTAG());
break;
#ifdef VIENNACL_WITH_OPENCL
case viennacl::OPENCL_MEMORY:
viennacl::linalg::opencl::inplace_solve(mat, vec, SOLVERTAG());
break;
#endif
#ifdef VIENNACL_WITH_CUDA
case viennacl::CUDA_MEMORY:
viennacl::linalg::cuda::inplace_solve(mat, vec, SOLVERTAG());
break;
#endif
default:
throw "not implemented";
}
}
Common_type<Value_type<M1>, Value_type<M2> >
dot_product (const M1 &a, const M2 &b)
{
static_assert (a.order == 1, "");
static_assert (b.order == 1, "");
assert (a.size () == b.size ());
return inner_product (a.begin (), a.end (), b.begin (), size_t (0));
}
void bi::mean(const M1 X, V1 mu) {
/* pre-condition */
BI_ASSERT(X.size2() == mu.size());
const int N = X.size1();
typename sim_temp_vector<V1>::type w(N);
set_elements(w, 1.0);
gemv(1.0/N, X, w, 0.0, mu, 'T');
}
void checkMatrixEqual(M1 const& m1, M2 const& m2){
BOOST_REQUIRE_EQUAL(m1.size1(),m2.size1());
BOOST_REQUIRE_EQUAL(m1.size2(),m2.size2());
for(std::size_t i = 0; i != m2.size1(); ++i){
for(std::size_t j = 0; j != m2.size2(); ++j){
BOOST_CHECK_EQUAL(m1(i,j),m2(i,j));
}
}
}
void bi::mean(const M1 X, const V1 w, V2 mu) {
/* pre-conditions */
BI_ASSERT(X.size2() == mu.size());
BI_ASSERT(X.size1() == w.size());
typedef typename V1::value_type T;
T Wt = sum_reduce(w);
gemv(1.0/Wt, X, w, 0.0, mu, 'T');
}
void assertFinite(const M1 & A, std::string const & message = "")
{
for(int r = 0; r < A.rows(); r++)
{
for(int c = 0; c < A.cols(); c++)
{
ASSERT_TRUE(std::isfinite(A(r,c))) << std::endl << "Check for finite values failed at A(" << r << "," << c << "). Matrix A:" << std::endl << A << std::endl;
}
}
}
void bi::cov(const M1 X, const V1 mu, M2 Sigma) {
/* pre-conditions */
BI_ASSERT(X.size2() == mu.size());
BI_ASSERT(Sigma.size1() == mu.size() && Sigma.size2() == mu.size());
const int N = X.size1();
typename sim_temp_matrix<M2>::type Y(X.size1(), X.size2());
Y = X;
sub_rows(Y, mu);
syrk(1.0/(N - 1.0), Y, 0.0, Sigma, 'U', 'T');
}
bool check_Matrix(const M1 & m1, const M2& m2) {
bool equal = true;
for(int i = 0; i<m1.M(); i++)
for(int j = 0; j< m1.N(); j++)
{
if(std::abs(m1(i, j) - m2(i, j) ) / std::abs(m2(i, j)) > 0.1)
{
equal = false;
}
}
return equal;
}
void bi::cov(const GammaPdf& q, M1 Sigma) {
/* pre-condition */
BI_ASSERT(Sigma.size1() == q.size());
BI_ASSERT(Sigma.size2() == q.size());
real alpha = q.shape();
real beta = q.scale();
real sigma = alpha*std::pow(beta, 2);
Sigma.clear();
set_elements(diagonal(Sigma), sigma);
}
void bi::var(const M1 X, const V1 mu, V2 sigma) {
/* pre-conditions */
BI_ASSERT(X.size2() == mu.size());
BI_ASSERT(sigma.size() == mu.size());
const int N = X.size1();
typename sim_temp_matrix<M1>::type Z(X.size2(), X.size1());
Z = X;
sub_rows(Z, mu);
dot_columns(Z, sigma);
scal(1.0/(N - 1.0), sigma);
}
void bi::cov(const UniformPdf<V1>& q, M1 Sigma) {
/* pre-condition */
BI_ASSERT(Sigma.size1() == q.size());
BI_ASSERT(Sigma.size2() == q.size());
temp_host_vector<real>::type diff(q.size());
diff = q.upper();
sub_elements(diff, q.lower(), diff);
sq_elements(diff, diff);
Sigma.clear();
axpy(1.0/12.0, diff, diagonal(Sigma));
}
void bi::cross(const M1 X, const M2 Y, const V1 muX, const V2 muY,
M3 SigmaXY) {
/* pre-conditions */
BI_ASSERT(X.size2() == muX.size());
BI_ASSERT(Y.size2() == muY.size());
BI_ASSERT(X.size1() == Y.size1());
BI_ASSERT(SigmaXY.size1() == muX.size() && SigmaXY.size2() == muY.size());
const int N = X.size1();
gemm(1.0/(N - 1.0), X, Y, 0.0, SigmaXY, 'T', 'N');
ger(-N/(N - 1.0), muX, muY, SigmaXY);
}
void bi::cov(const InverseGammaPdf& q, M1 Sigma) {
/* pre-condition */
BI_ASSERT(Sigma.size1() == q.size());
BI_ASSERT(Sigma.size2() == q.size());
BI_ASSERT(q.shape() > 2.0);
real alpha = q.shape();
real beta = q.scale();
real sigma = std::pow(beta, 2)/(std::pow(alpha - 1.0, 2)*(alpha - 2.0));
Sigma.clear();
set_elements(diagonal(Sigma), sigma);
}
void expectNear(const M1 & A, const M2 & B, T tolerance, std::string const & message = "")
{
EXPECT_EQ((size_t)A.rows(),(size_t)B.rows()) << message << "\nMatrix A:\n" << A << "\nand matrix B\n" << B << "\nare not the same\n";
EXPECT_EQ((size_t)A.cols(),(size_t)B.cols()) << message << "\nMatrix A:\n" << A << "\nand matrix B\n" << B << "\nare not the same\n";
for(int r = 0; r < A.rows(); r++)
{
for(int c = 0; c < A.cols(); c++)
{
EXPECT_NEAR(A(r,c),B(r,c),tolerance) << message << "\nTolerance comparison failed at (" << r << "," << c << ")\n"
<< "\nMatrix A:\n" << A << "\nand matrix B\n" << B;
}
}
}
void assertEqual(const M1 & A, const M2 & B, std::string const & message = "")
{
ASSERT_EQ((size_t)A.rows(),(size_t)B.rows()) << message << "\nMatrix A:\n" << A << "\nand matrix B\n" << B << "\nare not the same\n";
ASSERT_EQ((size_t)A.cols(),(size_t)B.cols()) << message << "\nMatrix A:\n" << A << "\nand matrix B\n" << B << "\nare not the same\n";
for(int r = 0; r < A.rows(); r++)
{
for(int c = 0; c < A.cols(); c++)
{
ASSERT_EQ(A(r,c),B(r,c)) << message << "\nEquality comparison failed at (" << r << "," << c << ")\n"
<< "\nMatrix A:\n" << A << "\nand matrix B\n" << B;
}
}
}
bool compare_result(const M1& sm, const M2& m)
{
if(sm.size() != m.size())
return false;
if(sm.line() != m.line())
return false;
for(unsigned int i = 0; i < sm.size(); ++i)
{
if(sm.position(i) != m.position(i))
return false;
if(sm.length(i) != m.length(i))
return false;
}
return true;
}
void assertNear(const M1 & A, const M2 & B, T tolerance, std::string const & message = "")
{
// Note: If these assertions fail, they only abort this subroutine.
// see: http://code.google.com/p/googletest/wiki/AdvancedGuide#Using_Assertions_in_Sub-routines
// \todo better handling of this
ASSERT_EQ((size_t)A.rows(),(size_t)B.rows()) << message << "\nMatrix A:\n" << A << "\nand matrix B\n" << B << "\nare not the same\n";
ASSERT_EQ((size_t)A.cols(),(size_t)B.cols()) << message << "\nMatrix A:\n" << A << "\nand matrix B\n" << B << "\nare not the same\n";
for(int r = 0; r < A.rows(); r++)
{
for(int c = 0; c < A.cols(); c++)
{
ASSERT_NEAR(A(r,c),B(r,c),tolerance) << message << "\nTolerance comparison failed at (" << r << "," << c << ")\n"
<< "\nMatrix A:\n" << A << "\nand matrix B\n" << B;
}
}
}
void bi::cov(const M1 X, const V1 w, const V2 mu, M2 Sigma) {
/* pre-conditions */
BI_ASSERT(X.size2() == mu.size());
BI_ASSERT(X.size1() == w.size());
BI_ASSERT(Sigma.size1() == mu.size() && Sigma.size2() == mu.size());
typedef typename V1::value_type T;
typename sim_temp_matrix<M2>::type Y(X.size1(), X.size2());
typename sim_temp_matrix<M2>::type Z(X.size1(), X.size2());
typename sim_temp_vector<V2>::type v(w.size());
T Wt = sum_reduce(w);
Y = X;
sub_rows(Y, mu);
sqrt_elements(w, v);
gdmm(1.0, v, Y, 0.0, Z);
syrk(1.0/Wt, Z, 0.0, Sigma, 'U', 'T');
// alternative weight: 1.0/(Wt - W2t/Wt)
}
void bi::distance(const M1 X, const real h, M2 D) {
/* pre-conditions */
BI_ASSERT(D.size1() == D.size2());
BI_ASSERT(D.size1() == X.size1());
BI_ASSERT(!M2::on_device);
typedef typename M1::value_type T1;
FastGaussianKernel K(X.size2(), h);
typename temp_host_vector<T1>::type d(X.size2());
int i, j;
for (j = 0; j < D.size2(); ++j) {
for (i = 0; i <= j; ++i) {
d = row(X, i);
axpy(-1.0, row(X, j), d);
D(i, j) = K(dot(d));
}
}
}
void bi::var(const M1 X, const V1 w, const V2 mu, V3 sigma) {
/* pre-conditions */
BI_ASSERT(X.size2() == mu.size());
BI_ASSERT(X.size1() == w.size());
BI_ASSERT(sigma.size() == mu.size());
typedef typename V1::value_type T1;
typename sim_temp_matrix<M1>::type Z(X.size1(), X.size2());
typename sim_temp_matrix<M1>::type Y(X.size1(), X.size2());
typename sim_temp_vector<V2>::type v(w.size());
T1 Wt = sum_reduce(w);
Z = X;
sub_rows(Z, mu);
sqrt_elements(w, v);
gdmm(1.0, v, Z, 0.0, Y);
dot_columns(Y, sigma);
divscal_elements(sigma, Wt, sigma);
// alternative weight: 1.0/(Wt - W2t/Wt)
}
void bi::cross(const M1 X, const M2 Y, const V1 w, const V2 muX,
const V3 muY, M3 SigmaXY) {
/* pre-conditions */
BI_ASSERT(X.size2() == muX.size());
BI_ASSERT(Y.size2() == muY.size());
BI_ASSERT(X.size1() == Y.size1());
BI_ASSERT(X.size1() == w.size());
BI_ASSERT(Y.size1() == w.size());
BI_ASSERT(SigmaXY.size1() == muX.size() && SigmaXY.size2() == muY.size());
typedef typename V1::value_type T;
typename sim_temp_matrix<M3>::type Z(X.size1(), X.size2());
T Wt = sum_reduce(w);
T Wt2 = std::pow(Wt, 2);
T W2t = sumsq_reduce(w);
gdmm(1.0, w, X, 0.0, Z);
gemm(1.0/Wt, Z, Y, 0.0, SigmaXY, 'T', 'N');
ger(-1.0, muX, muY, SigmaXY);
matrix_scal(1.0/(1.0 - W2t/Wt2), SigmaXY);
}
void bi::inverse_gamma_log_densities(const M1 Z, const T1 alpha, const T1 beta,
V1 p, const bool clear) {
/* pre-condition */
BI_ASSERT(Z.size1() == p.size());
op_elements(vec(Z), vec(Z), inverse_gamma_log_density_functor<T1>(alpha, beta));
if (clear) {
sum_columns(Z, p);
} else {
typename sim_temp_vector<V1>::type p1(p.size());
sum_columns(Z, p1);
add_elements(p, p1, p);
}
}
void print_m2_valid_map(M1 M1array)
{
int line = 0x54;
printf("%02X\t", line);
int data[16];
M1array.read(line, data);
for (int bit = 15; bit >= 0; --bit)
{
printf("%d ", data[bit]);
}
}
void bi::gaussian_log_densities(const M1 Z, const T1 logZ, V1 p,
const bool clear) {
/* pre-condition */
BI_ASSERT(Z.size1() == p.size());
typedef typename V1::value_type T2;
if (clear) {
dot_rows(Z, p);
op_elements(p, p, gaussian_log_density_functor<T2>(logZ));
} else {
typename sim_temp_vector<V1>::type p1(p.size());
dot_rows(Z, p1);
op_elements(p1, p, p, gaussian_log_density_update_functor<T2>(logZ));
}
}
void print_m3_valid_map(M1 M1array)
{
for (int line = 0x50; line < 0x54; ++line) // Line
{
printf("%02X\t", line);
int data[16];
M1array.read(line, data);
for (int bit = 15; bit >= 0; --bit)
{
printf("%d ", data[bit]);
}
printf("\n");
}
}
void check_LU_res(const M1 & m, const M2& lu)
{
GeneralMatrix l(m.M(), m.N());
GeneralMatrix u(m.M(), m.N());
for(int i = 0; i < lu.M(); i++)
{
for(int j = 0; j< lu.N(); j++)
{
if(i>j)
{
l(i, j) = lu(i, j);
u(i, j) = 0;
}
else if(i == j)
{
l(i, j) = 1;
u(i, j) = lu(i, j);
}
else
{
l(i, j) = 0;
u(i, j) = lu(i, j);
}
}
}
bool equal = true;
GeneralMatrix m1(m.M(), m.N());
mul(l, u, m1);
for(int i = 0; i<m.M(); i++)
for(int j = 0; j< m.N(); j++)
{
if(std::abs(m1(i, j) - m(i, j) ) / m(i, j) > 0.1)
{
equal = false;
}
}
if(!check_Matrix(m1,m))
{
std::cout<<"wrong answer!"<<std::endl;
}
else
{
std::cout<<"right answer, wahahahaha!"<<std::endl;
}
}
void print_m1_memory(M1 M1array)
{
for (int line = 0; line < 0x50; ++line) // Line
{
printf("%02X\t", line);
int data[16];
M1array.read(line, data);
for (int bit = 15; bit >= 0; --bit)
{
printf("%d", data[bit]);
// Add spacing between fields (type, x, tag, next, x)
if (bit == 14 || bit == 8 || bit == 9 || bit == 1)
{
printf(" ");
}
}
printf("\n");
}
}
static void TestAliasMultUL1(const M& m, M1& m1, std::string label)
{
TestAliasMultUL2(m,m.upperTri(),m.upperTri(),
m1,m1.upperTri(),m1.upperTri(),
label+" upperTri,upperTri");
TestAliasMultUL2(m,m.upperTri(),m.lowerTri(),
m1,m1.upperTri(),m1.lowerTri(),
label+" upperTri,lowerTri");
TestAliasMultUL2(m,m.lowerTri(),m.upperTri(),
m1,m1.lowerTri(),m1.upperTri(),
label+" lowerTri,upperTri");
TestAliasMultUL2(m,m.lowerTri(),m.lowerTri(),
m1,m1.lowerTri(),m1.lowerTri(),
label+" lowerTri,lowerTri");
TestAliasMultUL2(m,m.unitUpperTri(),m.upperTri(),
m1,m1.unitUpperTri(),m1.upperTri(),
label+" unitUpperTri,upperTri");
TestAliasMultUL2(m,m.unitUpperTri(),m.lowerTri(),
m1,m1.unitUpperTri(),m1.lowerTri(),
label+" unitUpperTri,lowerTri");
TestAliasMultUL2(m,m.unitLowerTri(),m.upperTri(),
m1,m1.unitLowerTri(),m1.upperTri(),
label+" unitLowerTri,upperTri");
TestAliasMultUL2(m,m.unitLowerTri(),m.lowerTri(),
m1,m1.unitLowerTri(),m1.lowerTri(),
label+" unitLowerTri,lowerTri");
TestAliasMultUL2(m,m.upperTri(),m.unitUpperTri(),
m1,m1.upperTri(),m1.unitUpperTri(),
label+" upperTri,unitUpperTri");
TestAliasMultUL2(m,m.upperTri(),m.unitLowerTri(),
m1,m1.upperTri(),m1.unitLowerTri(),
label+" upperTri,unitLowerTri");
TestAliasMultUL2(m,m.lowerTri(),m.unitUpperTri(),
m1,m1.lowerTri(),m1.unitUpperTri(),
label+" lowerTri,unitUpperTri");
TestAliasMultUL2(m,m.lowerTri(),m.unitLowerTri(),
m1,m1.lowerTri(),m1.unitLowerTri(),
label+" lowerTri,unitLowerTri");
TestAliasMultUL2(m,m.unitUpperTri(),m.unitUpperTri(),
m1,m1.unitUpperTri(),m1.unitUpperTri(),
label+" unitUpperTri,unitUpperTri");
TestAliasMultUL2(m,m.unitUpperTri(),m.unitLowerTri(),
m1,m1.unitUpperTri(),m1.unitLowerTri(),
label+" unitUpperTri,unitLowerTri");
TestAliasMultUL2(m,m.unitLowerTri(),m.unitUpperTri(),
m1,m1.unitLowerTri(),m1.unitUpperTri(),
label+" unitLowerTri,unitUpperTri");
TestAliasMultUL2(m,m.unitLowerTri(),m.unitLowerTri(),
m1,m1.unitLowerTri(),m1.unitLowerTri(),
label+" unitLowerTri,unitLowerTri");
}
void checkDenseMatrixEqual(M1 const& m1, M2 const& m2){
BOOST_REQUIRE_EQUAL(m1.size1(),m2.size1());
BOOST_REQUIRE_EQUAL(m1.size2(),m2.size2());
//indexed access
for(std::size_t i = 0; i != m2.size1(); ++i){
for(std::size_t j = 0; j != m2.size2(); ++j){
BOOST_CHECK_EQUAL(m1(i,j),m2(i,j));
}
}
//iterator access rows
for(std::size_t i = 0; i != m2.size1(); ++i){
typedef typename M1::const_row_iterator Iter;
BOOST_REQUIRE_EQUAL(m1.row_end(i)-m1.row_begin(i), m1.size2());
std::size_t k = 0;
for(Iter it = m1.row_begin(i); it != m1.row_end(i); ++it,++k){
BOOST_CHECK_EQUAL(k,it.index());
BOOST_CHECK_EQUAL(*it,m2(i,k));
}
//test that the actual iterated length equals the number of elements
BOOST_CHECK_EQUAL(k, m1.size2());
}
//iterator access columns
for(std::size_t i = 0; i != m2.size2(); ++i){
typedef typename M1::const_column_iterator Iter;
BOOST_REQUIRE_EQUAL(m1.column_end(i)-m1.column_begin(i), m1.size1());
std::size_t k = 0;
for(Iter it = m1.column_begin(i); it != m1.column_end(i); ++it,++k){
BOOST_CHECK_EQUAL(k,it.index());
BOOST_CHECK_EQUAL(*it,m2(k,i));
}
//test that the actual iterated length equals the number of elements
BOOST_CHECK_EQUAL(k, m1.size1());
}
}
