implement batched serial getrs

[yasahi-hpc]

This PR implements getrs function.

Following files are added:

1. KokkosBatched_Getrs_Serial_Impl.hpp: Internal interfaces
2. KokkosBatched_Getrs_Serial_Internal.hpp: Implementation details
3. KokkosBatched_Getrs.hpp: APIs
4. Test_Batched_SerialGetrs.hpp: Unit tests for that

Detailed description

It solves a general N-by-N matrix A using the LU factorization computed by getrf.
Here, the matrix has the following shape.

• A: (batch_count, n, n)
  The N-by-N factorized matrix by getrf where A = P * L * U; the unit diagonal elements of L are not stored.
• IPIV: (batch_count, n)
  The pivot indices from getrf. for 0 <= i < n, row i of the matrix was interchanged with row IPIV(i).

Parallelization would be made in the following manner. This is efficient only when
A is given in LayoutLeft for GPUs and LayoutRight for CPUs (parallelized over batch direction).

Kokkos::parallel_for('getrs', 
    Kokkos::RangePolicy<execution_space> policy(0, n),
    [=](const int k) {
        auto aa = Kokkos::subview(m_a, k, Kokkos::ALL(), Kokkos::ALL());
        auto ipiv = Kokkos::subview(m_ipiv, k, Kokkos::ALL());
        auto bb   = Kokkos::subview(m_b, k, Kokkos::ALL());

        KokkosBatched::SerialGetrs<Trans, AlgoTagType>::invoke(aa, ipiv, bb);
    });

Tests

1. Make a random matrix from random A and factorize it into LU with ipiv by getrf.
   Then, solve A * x = b with getrs to get x, while keeping the original b in x_ref. Finally, confirm that A * x is equal to b (=x_ref) using gem.
2. Simple and small analytical test, i.e. choose A as follows to confirm LU == A.

A: [[1, 1],
    [1, -1]]
b: [2, 0]
x: [1, 1]

[lucbv]

It looks good but I would rewrite the analytical test to only use getrs.

[lucbv]

In my opinion here it would be better to not call getrf but instead directly write the output of LU into A and ipiv and only test getrs the idea is to isolate where the error could be coming from. That way this unit test will only fail if an issue is found in getrs not in getrs. For instance you could have A, lu, ipiv and b set as follows:

A=[[1, 1]
      [1, -1]]
ipiv=[0,1]
lu=[[1, 1]]
       [1, -2]
b=[[2]
      [0]]

Then call directly getrs and check that the ouput is x=[[1],[1]]

[lucbv]

Thanks for the update