```/* nag_complex_banded_eigensystem_solve (f12auc) Example Program.
*
* Copyright 2017 Numerical Algorithms Group.
*
* Mark 26.2, 2017.
*/
#include <math.h>
#include <nag.h>
#include <nag_stdlib.h>
#include <naga02.h>
#include <nagf12.h>
#include <nagf16.h>
#include <nagx04.h>

#define AB(I, J) ab[(J-1)*pdab + kl + ku + I - J]
#define MB(I,J) mb[(J-1)*pdab + kl + ku + I - J]

int main(void)
{

Integer exit_status = 0;
Complex one = { 1.0, 0.0 };
Complex minusone = { -1.0, 0.0 };
Complex zero = { 0.0, 0.0 };
Nag_Boolean print_res = Nag_FALSE;
/* Scalars */
Complex ch_sub, ch_sup, alpha, sigma;
double h, rho, anorm;
Integer j, kl, ku, lcomm, licomm, n, ncol, nconv, ncv, nev, nx;
Integer pdab, pdmb, pdv;
/* Arrays */
Complex commd[1];
Integer icommd[1];
Complex *ab = 0, *ax = 0, *comm = 0, *d = 0, *mb = 0;
Complex *mx = 0, *resid = 0, *v = 0;
double *d_print = 0;
Integer *icomm = 0;
/* NAG types */
NagError fail;
Nag_OrderType order = Nag_ColMajor;
Nag_MatrixType matrix = Nag_GeneralMatrix;
Nag_DiagType diag = Nag_NonUnitDiag;
Nag_TransType trans = Nag_NoTrans;
INIT_FAIL(fail);

printf("nag_complex_banded_eigensystem_solve (f12auc) Example Program "
"Results\n\n");
fflush(stdout);
/* Skip heading in data file */
scanf("%*[^\n] ");
/* Read mesh size, number of eigenvalues wanted and size of subspace. */
scanf("%" NAG_IFMT "%" NAG_IFMT "%" NAG_IFMT "%*[^\n] ", &nx, &nev, &ncv);
/* Read complex value close to which eigenvalues are sought. */
scanf(" ( %lf , %lf ) %*[^\n] ", &sigma.re, &sigma.im);

n = nx * nx;
/* Initialize for the solution of a complex banded eigenproblem using
* nag_complex_banded_eigensystem_init (f12atc).
* But first get the required array lengths using arrays of length 1
* to store required lengths.
*/
licomm = -1;
lcomm = -1;
nag_complex_banded_eigensystem_init(n, nev, ncv, icommd, licomm, commd,
lcomm, &fail);
licomm = icommd[0];
lcomm = (Integer) (commd[0].re);
if (!(icomm = NAG_ALLOC((MAX(1, licomm)), Integer)) ||
!(comm = NAG_ALLOC((MAX(1, lcomm)), Complex))
)
{
printf("Allocation failure\n");
exit_status = -1;
goto END;
}
nag_complex_banded_eigensystem_init(n, nev, ncv, icomm, licomm, comm, lcomm,
&fail);
if (fail.code != NE_NOERROR) {
printf("Error from nag_complex_sparse_eigensystem_init (f12anc).\n%s\n",
fail.message);
exit_status = 1;
goto END;
}

/* Set options to show that the problem is a generalized eigenproblem and
* that eigenvalues are to be computed using shifted inverses using
* nag_complex_sparse_eigensystem_option (f12arc).
*/
nag_complex_sparse_eigensystem_option("SHIFTED INVERSE", icomm, comm,
&fail);
nag_complex_sparse_eigensystem_option("GENERALIZED", icomm, comm, &fail);
if (fail.code != NE_NOERROR) {
printf("Error from nag_complex_sparse_eigensystem_option (f12arc).\n%s\n",
fail.message);
exit_status = 2;
goto END;
}

/* Construct the matrix A in banded form and store in AB.
* KU, KL are number of superdiagonals and subdiagonals within
* the band of matrices A and M.
*/
kl = nx;
ku = nx;
pdab = 2 * kl + ku + 1;
pdmb = pdab;
if (!(ab = NAG_ALLOC(pdab * n, Complex)) ||
!(mb = NAG_ALLOC(pdmb * n, Complex))
)
{
printf("Allocation failure\n");
exit_status = -2;
goto END;
}

/* Zero out AB and MB. */
for (j = 0; j < pdab * n; j++) {
ab[j] = zero;
mb[j] = zero;
}

rho = 100.0;
h = 1.0 / (double) (nx + 1);
/* assign complex values using nag_complex (a02bac). */
ch_sub = nag_complex(0.5 * h * rho - 1.0, 0.0);
ch_sup = nag_complex(-0.5 * h * rho - 1.0, 0.0);

/* Set main diagonal of A and B to (4,0);
* first subdiagonal and superdiagonal of A are (-1 +/- rho/2h,0)..
* Outermost subdiagonal and superdiagonal are (-1,0).
*/
for (j = 1; j <= n; j++) {
AB(j, j) = nag_complex(4.0, 0.0);
MB(j, j) = nag_complex(4.0, 0.0);
if ((j - 1) % nx != 0 && j != n) {
AB(j + 1, j) = ch_sub;
}
if (j % nx != 0 && j != 1) {
AB(j - 1, j) = ch_sup;
}
if (j <= n - kl)
AB(j + kl, j) = minusone;
if (j > ku)
AB(j - ku, j) = minusone;
}
for (j = 2; j < n; j++) {
MB(j + 1, j) = one;
}
for (j = 2; j < n; j++) {
MB(j - 1, j) = one;
}

/* Allocate v to hold eigenvectors and d to hold eigenvalues. */
pdv = n;
if (!(d = NAG_ALLOC((nev), Complex)) ||
!(v = NAG_ALLOC((pdv) * (ncv), Complex)) ||
!(resid = NAG_ALLOC((n), Complex))
)
{
printf("Allocation failure\n");
exit_status = -3;
goto END;
}
/* Find eigenvalues closest in value to sigma and corresponding
* eigenvectors using nag_complex_banded_eigensystem_solve (f12auc).
*/
nag_complex_banded_eigensystem_solve(kl, ku, ab, mb, sigma, &nconv, d,
v, resid, v, comm, icomm, &fail);
if (fail.code != NE_NOERROR) {
printf("Error from nag_complex_banded_eigensystem_solve (f12auc).\n%s\n",
fail.message);
exit_status = 3;
goto END;
}

/* d_print stores eigenvalues (and possibly residuals) as real array. */
if (!(d_print = NAG_ALLOC(nconv * 3, double)))
{
printf("Allocation failure\n");
exit_status = -4;
goto END;
}
for (j = 0; j < nconv; j++) {
d_print[j] = (d[j]).re;
d_print[j + nconv] = (d[j]).im;
}
/* By default this example will not calculate and print residuals.
* It will, however if the following line is uncommented.
*/
/* print_res = Nag_TRUE; */
if (print_res) {
ncol = 3;
/* Compute the residual norm  ||A*x - lambda*B*x||.
* Matrix vector products Ax and Bx, for complex banded A and B, are formed
* using nag_zgbmv (f16sbc).
* The scaled vector subtraction is performed using nag_zaxpby (f16gcc).
*/
if (!(ax = NAG_ALLOC(n, Complex)) || !(mx = NAG_ALLOC(n, Complex))
)
{
printf("Allocation failure\n");
exit_status = -4;
goto END;
}
for (j = 0; j < nconv; j++) {
nag_zgbmv(order, trans, n, n, kl, ku, one, &ab[kl], pdab, &v[pdv * j],
1, zero, ax, 1, &fail);
if (fail.code == NE_NOERROR) {
nag_zgbmv(order, trans, n, n, kl, ku, one, &mb[kl], pdmb, &v[pdv * j],
1, zero, mx, 1, &fail);
if (fail.code == NE_NOERROR) {
/* alpha holds -d[j] using nag_complex_negate (a02cec). */
alpha = nag_complex_negate(d[j]);
nag_zaxpby(n, alpha, mx, 1, one, ax, 1, &fail);
}
}
if (fail.code != NE_NOERROR) {
printf("Error in calculating residual norm.\n%s\n", fail.message);
exit_status = 4;
goto END;
}
/* Get ||ax|| = ||Ax - lambda Bx|| using nag_zge_norm (f16uac)
* with the Frobenius norm on a complex general matrix with one column.
*/
nag_zge_norm(order, Nag_FrobeniusNorm, n, 1, ax, n, &anorm, &fail);
if (fail.code != NE_NOERROR) {
printf("Error from nag_zge_norm (f16uac).\n%s\n", fail.message);
exit_status = 5;
goto END;
}
/* nag_complex_abs (a02dbc) returns the modulus of the eigenvalue */
d_print[j + 2 * nconv] = anorm / nag_complex_abs(d[j]);
}
}
else {
ncol = 2;
}
printf("\n");

/* Print the eigenvalues (and possibly the residuals) using the matrix
* printer, nag_gen_real_mat_print (x04cac).
*/
printf("  Number of eigenvalues wanted     = %" NAG_IFMT "\n", nev);
printf("  Number of eigenvalues converged  = %" NAG_IFMT "\n", nconv);
printf("  Eigenvalues are closest to Sigma = ( %lf , %lf )\n\n",
sigma.re, sigma.im);
fflush(stdout);
nag_gen_real_mat_print(order, matrix, diag, nconv, ncol, d_print, nconv,
" Ritz values closest to sigma", 0, &fail);
if (fail.code != NE_NOERROR) {
printf("Error from nag_gen_real_mat_print (x04cac).\n%s\n", fail.message);
exit_status = 6;
}
END:
NAG_FREE(ab);
NAG_FREE(ax);
NAG_FREE(comm);
NAG_FREE(d);
NAG_FREE(mb);
NAG_FREE(mx);
NAG_FREE(resid);
NAG_FREE(v);
NAG_FREE(d_print);
NAG_FREE(icomm);
return exit_status;
}
```