add preconditioner and solver transpose tests

This only tests the core implementation since
there are no kernels involved

Also fixes a (recurring) bug with typeid

include/ginkgo/core/base/utils.hpp

@@ -346,7 +346,7 @@ inline std::unique_ptr<typename std::decay<T>::type> as(
  return std::unique_ptr<typename std::decay<T>::type>{p};
  } else {
  throw NotSupported(__FILE__, __LINE__, __func__,
- name_demangling::get_type_name(typeid(obj.get())));
+ name_demangling::get_type_name(typeid(*obj)));
  }
 }
 
@@ -370,7 +370,7 @@ inline std::shared_ptr<typename std::decay<T>::type> as(std::shared_ptr<U> obj)
  return ptr;
  } else {
  throw NotSupported(__FILE__, __LINE__, __func__,
- name_demangling::get_type_name(typeid(obj.get())));
+ name_demangling::get_type_name(typeid(*obj)));
  }
 }
 
@@ -398,7 +398,7 @@ inline std::shared_ptr<const typename std::decay<T>::type> as(
  return ptr;
  } else {
  throw NotSupported(__FILE__, __LINE__, __func__,
- name_demangling::get_type_name(typeid(obj.get())));
+ name_demangling::get_type_name(typeid(*obj)));
  }
 }
 

reference/test/preconditioner/ilu.cpp

@@ -52,6 +52,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 
 #include "core/test/utils.hpp"
+#include "core/test/utils/assertions.hpp"
 
 
 namespace {
@@ -245,6 +246,52 @@ TYPED_TEST(Ilu, CanBeCloned)
 }
 
 
+TYPED_TEST(Ilu, CanBeTransposed)
+{
+ using Ilu = typename TestFixture::ilu_prec_type;
+ using Mtx = typename TestFixture::Mtx;
+ auto ilu = this->ilu_pre_factory->generate(this->l_u_composition);
+
+ auto transp = gko::as<Ilu>(ilu->transpose());
+
+ auto l_ref = gko::as<Mtx>(ilu->get_l_solver()->get_system_matrix());
+ auto u_ref = gko::as<Mtx>(ilu->get_u_solver()->get_system_matrix());
+ auto l_transp = gko::as<Mtx>(
+ gko::as<Mtx>(transp->get_u_solver()->get_system_matrix())->transpose());
+ auto u_transp = gko::as<Mtx>(
+ gko::as<Mtx>(transp->get_l_solver()->get_system_matrix())->transpose());
+
+ GKO_ASSERT_MTX_EQ_SPARSITY(l_ref, l_transp);
+ GKO_ASSERT_MTX_EQ_SPARSITY(u_ref, u_transp);
+ GKO_ASSERT_MTX_NEAR(l_ref, l_transp, 0);
+ GKO_ASSERT_MTX_NEAR(u_ref, u_transp, 0);
+}
+
+
+TYPED_TEST(Ilu, CanBeConjTransposed)
+{
+ using Ilu = typename TestFixture::ilu_prec_type;
+ using Mtx = typename TestFixture::Mtx;
+ auto ilu = this->ilu_pre_factory->generate(this->l_u_composition);
+
+ auto transp = gko::as<Ilu>(ilu->conj_transpose());
+
+ auto l_ref = gko::as<Mtx>(ilu->get_l_solver()->get_system_matrix());
+ auto u_ref = gko::as<Mtx>(ilu->get_u_solver()->get_system_matrix());
+ auto l_transp =
+ gko::as<Mtx>(gko::as<Mtx>(transp->get_u_solver()->get_system_matrix())
+ ->conj_transpose());
+ auto u_transp =
+ gko::as<Mtx>(gko::as<Mtx>(transp->get_l_solver()->get_system_matrix())
+ ->conj_transpose());
+
+ GKO_ASSERT_MTX_EQ_SPARSITY(l_ref, l_transp);
+ GKO_ASSERT_MTX_EQ_SPARSITY(u_ref, u_transp);
+ GKO_ASSERT_MTX_NEAR(l_ref, l_transp, 0);
+ GKO_ASSERT_MTX_NEAR(u_ref, u_transp, 0);
+}
+
+
 TYPED_TEST(Ilu, SolvesCustomTypeDefaultFactorySingleRhs)
 {
  using ilu_prec_type = typename TestFixture::ilu_prec_type;

reference/test/preconditioner/isai_kernels.cpp

@@ -857,4 +857,68 @@ TYPED_TEST(Isai, UseWithIluPreconditioner)
 }
 
 
+TYPED_TEST(Isai, ReturnsTransposedCorrectInverseL)
+{
+ using UpperIsai = typename TestFixture::UpperIsai;
+ using Csr = typename TestFixture::Csr;
+ using value_type = typename TestFixture::value_type;
+ const auto isai = this->lower_isai_factory->generate(this->l_sparse);
+
+ auto l_inv = gko::as<Csr>(gko::as<UpperIsai>(isai->transpose())
+ ->get_approximate_inverse()
+ ->transpose());
+
+ GKO_ASSERT_MTX_EQ_SPARSITY(l_inv, this->l_sparse_inv);
+ GKO_ASSERT_MTX_NEAR(l_inv, this->l_sparse_inv, r<value_type>::value);
+}
+
+
+TYPED_TEST(Isai, ReturnsTransposedCorrectInverseU)
+{
+ using LowerIsai = typename TestFixture::LowerIsai;
+ using Csr = typename TestFixture::Csr;
+ using value_type = typename TestFixture::value_type;
+ const auto isai = this->upper_isai_factory->generate(this->u_sparse);
+
+ auto u_inv = gko::as<Csr>(gko::as<LowerIsai>(isai->transpose())
+ ->get_approximate_inverse()
+ ->transpose());
+
+ GKO_ASSERT_MTX_EQ_SPARSITY(u_inv, this->u_sparse_inv);
+ GKO_ASSERT_MTX_NEAR(u_inv, this->u_sparse_inv, r<value_type>::value);
+}
+
+
+TYPED_TEST(Isai, ReturnsConjTransposedCorrectInverseL)
+{
+ using UpperIsai = typename TestFixture::UpperIsai;
+ using Csr = typename TestFixture::Csr;
+ using value_type = typename TestFixture::value_type;
+ const auto isai = this->lower_isai_factory->generate(this->l_sparse);
+
+ auto l_inv = gko::as<Csr>(gko::as<UpperIsai>(isai->conj_transpose())
+ ->get_approximate_inverse()
+ ->conj_transpose());
+
+ GKO_ASSERT_MTX_EQ_SPARSITY(l_inv, this->l_sparse_inv);
+ GKO_ASSERT_MTX_NEAR(l_inv, this->l_sparse_inv, r<value_type>::value);
+}
+
+
+TYPED_TEST(Isai, ReturnsConjTransposedCorrectInverseU)
+{
+ using LowerIsai = typename TestFixture::LowerIsai;
+ using Csr = typename TestFixture::Csr;
+ using value_type = typename TestFixture::value_type;
+ const auto isai = this->upper_isai_factory->generate(this->u_sparse);
+
+ auto u_inv = gko::as<Csr>(gko::as<LowerIsai>(isai->conj_transpose())
+ ->get_approximate_inverse()
+ ->conj_transpose());
+
+ GKO_ASSERT_MTX_EQ_SPARSITY(u_inv, this->u_sparse_inv);
+ GKO_ASSERT_MTX_NEAR(u_inv, this->u_sparse_inv, r<value_type>::value);
+}
+
+
 } // namespace

reference/test/solver/bicg_kernels.cpp

@@ -305,4 +305,34 @@ TYPED_TEST(Bicg, SolvesMultipleDenseSystemForDivergenceCheck)
 }
 
 
+TYPED_TEST(Bicg, SolvesTransposedNonSymmetricStencilSystem)
+{
+ using Mtx = typename TestFixture::Mtx;
+ using value_type = typename TestFixture::value_type;
+ auto solver =
+ this->bicg_factory->generate(this->mtx_non_symmetric->transpose());
+ auto b = gko::initialize<Mtx>({13.0, 7.0, 1.0}, this->exec);
+ auto x = gko::initialize<Mtx>({0.0, 0.0, 0.0}, this->exec);
+
+ solver->transpose()->apply(b.get(), x.get());
+
+ GKO_ASSERT_MTX_NEAR(x, l({1.0, 3.0, 2.0}), r<value_type>::value * 1e2);
+}
+
+
+TYPED_TEST(Bicg, SolvesConjTransposedNonSymmetricStencilSystem)
+{
+ using Mtx = typename TestFixture::Mtx;
+ using value_type = typename TestFixture::value_type;
+ auto solver =
+ this->bicg_factory->generate(this->mtx_non_symmetric->conj_transpose());
+ auto b = gko::initialize<Mtx>({13.0, 7.0, 1.0}, this->exec);
+ auto x = gko::initialize<Mtx>({0.0, 0.0, 0.0}, this->exec);
+
+ solver->conj_transpose()->apply(b.get(), x.get());
+
+ GKO_ASSERT_MTX_NEAR(x, l({1.0, 3.0, 2.0}), r<value_type>::value * 1e2);
+}
+
+
 } // namespace

reference/test/solver/bicgstab_kernels.cpp

@@ -318,4 +318,34 @@ TYPED_TEST(Bicgstab, SolvesMultipleDenseSystemsDivergenceCheck)
 }
 
 
+TYPED_TEST(Bicgstab, SolvesTransposedDenseSystem)
+{
+ using Mtx = typename TestFixture::Mtx;
+ using value_type = typename TestFixture::value_type;
+ auto half_tol = std::sqrt(r<value_type>::value);
+ auto solver = this->bicgstab_factory->generate(this->mtx->transpose());
+ auto b = gko::initialize<Mtx>({-1.0, 3.0, 1.0}, this->exec);
+ auto x = gko::initialize<Mtx>({0.0, 0.0, 0.0}, this->exec);
+
+ solver->transpose()->apply(b.get(), x.get());
+
+ GKO_ASSERT_MTX_NEAR(x, l({-4.0, -1.0, 4.0}), half_tol);
+}
+
+
+TYPED_TEST(Bicgstab, SolvesConjTransposedDenseSystem)
+{
+ using Mtx = typename TestFixture::Mtx;
+ using value_type = typename TestFixture::value_type;
+ auto half_tol = std::sqrt(r<value_type>::value);
+ auto solver = this->bicgstab_factory->generate(this->mtx->conj_transpose());
+ auto b = gko::initialize<Mtx>({-1.0, 3.0, 1.0}, this->exec);
+ auto x = gko::initialize<Mtx>({0.0, 0.0, 0.0}, this->exec);
+
+ solver->conj_transpose()->apply(b.get(), x.get());
+
+ GKO_ASSERT_MTX_NEAR(x, l({-4.0, -1.0, 4.0}), half_tol);
+}
+
+
 } // namespace

reference/test/solver/cg_kernels.cpp

@@ -285,4 +285,38 @@ TYPED_TEST(Cg, SolvesMultipleDenseSystemForDivergenceCheck)
 }
 
 
+TYPED_TEST(Cg, SolvesTransposedBigDenseSystem)
+{
+ using Mtx = typename TestFixture::Mtx;
+ using value_type = typename TestFixture::value_type;
+ auto solver = this->cg_factory_big->generate(this->mtx_big);
+ auto b = gko::initialize<Mtx>(
+ {1300083.0, 1018120.5, 906410.0, -42679.5, 846779.5, 1176858.5},
+ this->exec);
+ auto x = gko::initialize<Mtx>({0.0, 0.0, 0.0, 0.0, 0.0, 0.0}, this->exec);
+
+ solver->transpose()->apply(b.get(), x.get());
+
+ GKO_ASSERT_MTX_NEAR(x, l({81.0, 55.0, 45.0, 5.0, 85.0, -10.0}),
+ r<value_type>::value * 1e2);
+}
+
+
+TYPED_TEST(Cg, SolvesConjTransposedBigDenseSystem)
+{
+ using Mtx = typename TestFixture::Mtx;
+ using value_type = typename TestFixture::value_type;
+ auto solver = this->cg_factory_big->generate(this->mtx_big);
+ auto b = gko::initialize<Mtx>(
+ {1300083.0, 1018120.5, 906410.0, -42679.5, 846779.5, 1176858.5},
+ this->exec);
+ auto x = gko::initialize<Mtx>({0.0, 0.0, 0.0, 0.0, 0.0, 0.0}, this->exec);
+
+ solver->conj_transpose()->apply(b.get(), x.get());
+
+ GKO_ASSERT_MTX_NEAR(x, l({81.0, 55.0, 45.0, 5.0, 85.0, -10.0}),
+ r<value_type>::value * 1e2);
+}
+
+
 } // namespace

reference/test/solver/cgs_kernels.cpp

@@ -284,4 +284,36 @@ TYPED_TEST(Cgs, SolvesMultipleDenseSystems)
 }
 
 
+TYPED_TEST(Cgs, SolvesTransposedBigDenseSystem)
+{
+ using Mtx = typename TestFixture::Mtx;
+ using value_type = typename TestFixture::value_type;
+ auto solver = this->cgs_factory_big->generate(this->mtx_big);
+ auto b = gko::initialize<Mtx>(
+ {764.0, -4032.0, -11855.0, 7111.0, -12765.0, -4589}, this->exec);
+ auto x = gko::initialize<Mtx>({0.0, 0.0, 0.0, 0.0, 0.0, 0.0}, this->exec);
+
+ solver->transpose()->apply(b.get(), x.get());
+
+ GKO_ASSERT_MTX_NEAR(x, l({-13.0, -49.0, 69.0, -33.0, -82.0, -39.0}),
+ r<value_type>::value * 1e3);
+}
+
+
+TYPED_TEST(Cgs, SolvesConjTransposedBigDenseSystem)
+{
+ using Mtx = typename TestFixture::Mtx;
+ using value_type = typename TestFixture::value_type;
+ auto solver = this->cgs_factory_big->generate(this->mtx_big);
+ auto b = gko::initialize<Mtx>(
+ {764.0, -4032.0, -11855.0, 7111.0, -12765.0, -4589}, this->exec);
+ auto x = gko::initialize<Mtx>({0.0, 0.0, 0.0, 0.0, 0.0, 0.0}, this->exec);
+
+ solver->conj_transpose()->apply(b.get(), x.get());
+
+ GKO_ASSERT_MTX_NEAR(x, l({-13.0, -49.0, 69.0, -33.0, -82.0, -39.0}),
+ r<value_type>::value * 1e3);
+}
+
+
 } // namespace

reference/test/solver/fcg_kernels.cpp

@@ -284,5 +284,37 @@ TYPED_TEST(Fcg, SolvesMultipleBigDenseSystems)
  GKO_ASSERT_MTX_NEAR(xc, mergedRes, r<value_type>::value);
 }
 
+TYPED_TEST(Fcg, SolvesTransposedBigDenseSystem)
+{
+ using Mtx = typename TestFixture::Mtx;
+ using value_type = typename TestFixture::value_type;
+ auto solver = this->fcg_factory_big->generate(this->mtx_big);
+ auto b = gko::initialize<Mtx>(
+ {1300083.0, 1018120.5, 906410.0, -42679.5, 846779.5, 1176858.5},
+ this->exec);
+ auto x = gko::initialize<Mtx>({0.0, 0.0, 0.0, 0.0, 0.0, 0.0}, this->exec);
+
+ solver->transpose()->apply(b.get(), x.get());
+
+ GKO_ASSERT_MTX_NEAR(x, l({81.0, 55.0, 45.0, 5.0, 85.0, -10.0}),
+ r<value_type>::value * 1e3);
+}
+
+TYPED_TEST(Fcg, SolvesConjTransposedBigDenseSystem)
+{
+ using Mtx = typename TestFixture::Mtx;
+ using value_type = typename TestFixture::value_type;
+ auto solver = this->fcg_factory_big->generate(this->mtx_big);
+ auto b = gko::initialize<Mtx>(
+ {1300083.0, 1018120.5, 906410.0, -42679.5, 846779.5, 1176858.5},
+ this->exec);
+ auto x = gko::initialize<Mtx>({0.0, 0.0, 0.0, 0.0, 0.0, 0.0}, this->exec);
+
+ solver->conj_transpose()->apply(b.get(), x.get());
+
+ GKO_ASSERT_MTX_NEAR(x, l({81.0, 55.0, 45.0, 5.0, 85.0, -10.0}),
+ r<value_type>::value * 1e3);
+}
+
 
 } // namespace

reference/test/solver/gmres_kernels.cpp

@@ -353,4 +353,39 @@ TYPED_TEST(Gmres, SolvesWithPreconditioner)
 }
 
 
+TYPED_TEST(Gmres, SolvesTransposedBigDenseSystem)
+{
+ using Mtx = typename TestFixture::Mtx;
+ using value_type = typename TestFixture::value_type;
+ auto solver = this->gmres_factory_big->generate(this->mtx_big->transpose());
+ auto b = gko::initialize<Mtx>(
+ {72748.36, 297469.88, 347229.24, 36290.66, 82958.82, -80192.15},
+ this->exec);
+ auto x = gko::initialize<Mtx>({0.0, 0.0, 0.0, 0.0, 0.0, 0.0}, this->exec);
+
+ solver->transpose()->apply(b.get(), x.get());
+
+ GKO_ASSERT_MTX_NEAR(x, l({52.7, 85.4, 134.2, -250.0, -16.8, 35.3}),
+ r<value_type>::value * 1e3);
+}
+
+
+TYPED_TEST(Gmres, SolvesConjTransposedBigDenseSystem)
+{
+ using Mtx = typename TestFixture::Mtx;
+ using value_type = typename TestFixture::value_type;
+ auto solver =
+ this->gmres_factory_big->generate(this->mtx_big->conj_transpose());
+ auto b = gko::initialize<Mtx>(
+ {72748.36, 297469.88, 347229.24, 36290.66, 82958.82, -80192.15},
+ this->exec);
+ auto x = gko::initialize<Mtx>({0.0, 0.0, 0.0, 0.0, 0.0, 0.0}, this->exec);
+
+ solver->conj_transpose()->apply(b.get(), x.get());
+
+ GKO_ASSERT_MTX_NEAR(x, l({52.7, 85.4, 134.2, -250.0, -16.8, 35.3}),
+ r<value_type>::value * 1e3);
+}
+
+
 } // namespace