ppbsv

The ppbsv solver supports the following input types.

• data type: DSZC
• index type: std::int32_t, std::int64_t

ppbsv solves a square banded symmetric positive definite system A * X = B with bandwidth \(KLU\) using Cholesky factorization. The matrix A of size \(N\) is stored in a memory block of size \(N \times (KLU + 1)\).

!!! note Although KLU = 0 is supported, a zero bandwidth triggers an unwanted warning from ScaLAPACK.

Constructor

The solver takes three template arguments.

1. data type, e.g., double, float, std::complex<double>, std::complex<float>;
2. index type, e.g., std::int32_t, std::int64_t;
3. UPLO flag indicating which triangular half is stored, U (upper) or L (lower).

The solver uses a 1D process grid. It takes a single argument representing the number of rows in the grid.

1

auto solver = ppbsv<double, int, 'U'>(np_row);

Because the matrix is symmetric, ScaLAPACK expects only one half of it. The caller must provide the matrix exactly stored in a contiguous memory block of size \(N \times (KLU + 1)\). The internal storage layout varies with the UPLO flag.

Indexer

A nested indexer converts logical 2D indices \((i, j)\) into the correct 1D offset for the symmetric band storage layout, respecting the UPLO flag.

1
2
3

const auto IDX = par_dpbsv<int>::indexer{N, KLU};
A.resize(N * (KLU + 1), 0.);
for(auto I = 0; I < N; ++I) A[IDX(I, I)] = I + 1;

Solving

1
2
3
4
5
6
7

constexpr auto N = 6, NRHS = 2, KLU = 2;
// storage for the matrices A and B
std::vector<double> A, B;
// ...
// ... storage is populated by some utility on the root process
// ...
const auto info = solver.solve({N, N, KLU, A.data()}, {N, NRHS, B.data()});