blob: af4a08d7b2174fa3857220dce00da750189f8244 [file] [edit]
// SPDX-FileCopyrightText: The Eigen Authors
// SPDX-License-Identifier: MPL-2.0
// Runs the level-3 BLAS adapters (?gemm, ?symm and ?hemm, ?trmm) against the BLAS library the tests link: Eigen's own
// shared library unless EIGEN_TEST_EXTERNAL_BLAS. Parts 1 and 2 use column-major default storage, parts 3 and 4
// row-major default storage, under which the adapters' temporaries must still be column-major.
#if (defined(EIGEN_TEST_PART_3) || defined(EIGEN_TEST_PART_4)) && !defined(EIGEN_DEFAULT_TO_ROW_MAJOR)
#define EIGEN_DEFAULT_TO_ROW_MAJOR
#endif
#ifndef EIGEN_USE_BLAS
#define EIGEN_USE_BLAS
#endif
#include "main.h"
// Integer entries in [-3, 3] keep every sum exact in any order, so each BLAS product must equal the
// coefficient-based lazyProduct exactly.
template <typename Scalar, int LhsOrder, int RhsOrder, int DstOrder>
void blas_level3_gemm(Index rows, Index depth, Index cols) {
using Lhs = Matrix<Scalar, Dynamic, Dynamic, LhsOrder>;
using Rhs = Matrix<Scalar, Dynamic, Dynamic, RhsOrder>;
using Dst = Matrix<Scalar, Dynamic, Dynamic, DstOrder>;
const Lhs a = RandomIntegerMatrix<Lhs>(rows, depth, -3, 3);
const Lhs a_t = RandomIntegerMatrix<Lhs>(depth, rows, -3, 3);
const Rhs b = RandomIntegerMatrix<Rhs>(depth, cols, -3, 3);
const Rhs b_t = RandomIntegerMatrix<Rhs>(cols, depth, -3, 3);
const Dst c = RandomIntegerMatrix<Dst>(rows, cols, -3, 3);
Dst dst(rows, cols);
dst.noalias() = a * b;
VERIFY_IS_CWISE_EQUAL(dst, Dst(a.lazyProduct(b)));
dst.noalias() = a.conjugate() * b;
VERIFY_IS_CWISE_EQUAL(dst, Dst(a.conjugate().lazyProduct(b)));
dst.noalias() = a * b.conjugate();
VERIFY_IS_CWISE_EQUAL(dst, Dst(a.lazyProduct(b.conjugate())));
dst.noalias() = a_t.adjoint() * b_t.adjoint();
VERIFY_IS_CWISE_EQUAL(dst, Dst(a_t.adjoint().lazyProduct(b_t.adjoint())));
dst = c;
dst.noalias() += Scalar(2) * a.conjugate() * b.conjugate();
VERIFY_IS_CWISE_EQUAL(dst, Dst(c + Scalar(2) * a.conjugate().lazyProduct(b.conjugate())));
}
template <typename Scalar, int SelfadjointOrder, int OtherOrder, int DstOrder>
void blas_level3_symm(Index rows, Index cols) {
using Selfadjoint = Matrix<Scalar, Dynamic, Dynamic, SelfadjointOrder>;
using Other = Matrix<Scalar, Dynamic, Dynamic, OtherOrder>;
using Dst = Matrix<Scalar, Dynamic, Dynamic, DstOrder>;
using Real = typename NumTraits<Scalar>::Real;
Selfadjoint s_left = RandomIntegerMatrix<Selfadjoint>(rows, rows, -3, 3);
Selfadjoint s_right = RandomIntegerMatrix<Selfadjoint>(cols, cols, -3, 3);
// ?hemm reads only the real part of the diagonal.
s_left.diagonal() = s_left.diagonal().real().template cast<Scalar>();
s_right.diagonal() = s_right.diagonal().real().template cast<Scalar>();
const Selfadjoint lower_left = s_left.template selfadjointView<Lower>();
const Selfadjoint upper_left = s_left.template selfadjointView<Upper>();
const Selfadjoint lower_right = s_right.template selfadjointView<Lower>();
const Selfadjoint upper_right = s_right.template selfadjointView<Upper>();
const Other b = RandomIntegerMatrix<Other>(rows, cols, -3, 3);
const Dst c = RandomIntegerMatrix<Dst>(rows, cols, -3, 3);
Dst dst(rows, cols);
dst.noalias() = s_left.template selfadjointView<Lower>() * b;
VERIFY_IS_CWISE_EQUAL(dst, Dst(lower_left.lazyProduct(b)));
dst.noalias() = s_left.template selfadjointView<Upper>() * b.conjugate();
VERIFY_IS_CWISE_EQUAL(dst, Dst(upper_left.lazyProduct(b.conjugate())));
dst.noalias() = b * s_right.template selfadjointView<Upper>();
VERIFY_IS_CWISE_EQUAL(dst, Dst(b.lazyProduct(upper_right)));
dst = c;
dst.noalias() += Scalar(Real(-2)) * b.conjugate() * s_right.template selfadjointView<Lower>();
VERIFY_IS_CWISE_EQUAL(dst, Dst(c + Scalar(Real(-2)) * b.conjugate().lazyProduct(lower_right)));
}
template <int Mode, typename Triangular, typename Other, typename Dst>
void blas_level3_trmm_mode(const Triangular& t_left, const Triangular& t_right, const Other& b, const Dst& c) {
using Scalar = typename Dst::Scalar;
const Triangular left = t_left.template triangularView<Mode>();
const Triangular right = t_right.template triangularView<Mode>();
Dst dst(c.rows(), c.cols());
dst.noalias() = t_left.template triangularView<Mode>() * b;
VERIFY_IS_CWISE_EQUAL(dst, Dst(left.lazyProduct(b)));
dst.noalias() = t_left.template triangularView<Mode>().conjugate() * b.conjugate();
VERIFY_IS_CWISE_EQUAL(dst, Dst(left.conjugate().lazyProduct(b.conjugate())));
dst.noalias() = b * t_right.template triangularView<Mode>();
VERIFY_IS_CWISE_EQUAL(dst, Dst(b.lazyProduct(right)));
dst = c;
dst.noalias() += Scalar(2) * b.conjugate() * t_right.template triangularView<Mode>().conjugate();
VERIFY_IS_CWISE_EQUAL(dst, Dst(c + Scalar(2) * b.conjugate().lazyProduct(right.conjugate())));
}
template <typename Scalar, int TriangularOrder, int OtherOrder, int DstOrder>
void blas_level3_trmm(Index rows, Index cols) {
using Triangular = Matrix<Scalar, Dynamic, Dynamic, TriangularOrder>;
using Other = Matrix<Scalar, Dynamic, Dynamic, OtherOrder>;
using Dst = Matrix<Scalar, Dynamic, Dynamic, DstOrder>;
const Triangular t_left = RandomIntegerMatrix<Triangular>(rows, rows, -3, 3);
const Triangular t_right = RandomIntegerMatrix<Triangular>(cols, cols, -3, 3);
const Other b = RandomIntegerMatrix<Other>(rows, cols, -3, 3);
const Dst c = RandomIntegerMatrix<Dst>(rows, cols, -3, 3);
blas_level3_trmm_mode<Lower>(t_left, t_right, b, c);
blas_level3_trmm_mode<Upper>(t_left, t_right, b, c);
blas_level3_trmm_mode<UnitLower>(t_left, t_right, b, c);
blas_level3_trmm_mode<StrictlyUpper>(t_left, t_right, b, c);
}
template <typename Scalar, int LhsOrder, int RhsOrder, int DstOrder>
void blas_level3_case() {
// Distinct sizes, so that a transposed or misstrided operand cannot pass.
blas_level3_gemm<Scalar, LhsOrder, RhsOrder, DstOrder>(23, 17, 11);
blas_level3_gemm<Scalar, LhsOrder, RhsOrder, DstOrder>(11, 17, 23);
blas_level3_symm<Scalar, LhsOrder, RhsOrder, DstOrder>(23, 11);
blas_level3_symm<Scalar, LhsOrder, RhsOrder, DstOrder>(11, 23);
blas_level3_trmm<Scalar, LhsOrder, RhsOrder, DstOrder>(23, 11);
blas_level3_trmm<Scalar, LhsOrder, RhsOrder, DstOrder>(11, 23);
}
template <typename Scalar>
void blas_level3() {
blas_level3_case<Scalar, ColMajor, ColMajor, ColMajor>();
blas_level3_case<Scalar, ColMajor, RowMajor, ColMajor>();
blas_level3_case<Scalar, RowMajor, ColMajor, ColMajor>();
blas_level3_case<Scalar, RowMajor, RowMajor, ColMajor>();
blas_level3_case<Scalar, ColMajor, ColMajor, RowMajor>();
blas_level3_case<Scalar, ColMajor, RowMajor, RowMajor>();
blas_level3_case<Scalar, RowMajor, ColMajor, RowMajor>();
blas_level3_case<Scalar, RowMajor, RowMajor, RowMajor>();
}
EIGEN_DECLARE_TEST(blas_level3) {
for (int i = 0; i < g_repeat; ++i) {
CALL_SUBTEST_1(blas_level3<float>());
CALL_SUBTEST_1(blas_level3<double>());
CALL_SUBTEST_2(blas_level3<std::complex<float>>());
CALL_SUBTEST_2(blas_level3<std::complex<double>>());
CALL_SUBTEST_3(blas_level3<float>());
CALL_SUBTEST_3(blas_level3<double>());
CALL_SUBTEST_4(blas_level3<std::complex<float>>());
CALL_SUBTEST_4(blas_level3<std::complex<double>>());
}
}