### 2.1. `igraph_arpack_options_t` — Options for ARPACK

```typedef struct igraph_arpack_options_t {
/* INPUT */
char bmat[1];			/* I-standard problem, G-generalized */
long int n; 			/* Dimension of the eigenproblem */
char which[2];		/* LA, SA, LM, SM, BE */
long int nev;                 /* Number of eigenvalues to be computed */
igraph_real_t tol;		/* Stopping criterion */
long int ncv;			/* Number of columns in V */
long int ldv;			/* Leading dimension of V */
long int ishift;		/* 0-reverse comm., 1-exact with tridiagonal */
long int mxiter;              /* Maximum number of update iterations to take */
long int nb;			/* Block size on the recurrence, only 1 works */
long int mode;		/* The kind of problem to be solved (1-5)
1: A*x=l*x, A symmetric
2: A*x=l*M*x, A symm. M pos. def.
3: K*x = l*M*x, K symm., M pos. semidef.
4: K*x = l*KG*x, K s. pos. semidef. KG s. indef.
5: A*x = l*M*x, A symm., M symm. pos. semidef. */
long int start;		/* 0: random, 1: use the supplied vector */
long int lworkl;		/* Size of temporary storage, default is fine */
igraph_real_t sigma;          /* The shift for modes 3,4,5 */
igraph_real_t sigmai;		/* The imaginary part of shift for rnsolve */
/* OUTPUT */
long int info;		/* What happened, see docs */
long int ierr;		/* What happened  in the dseupd call */
long int noiter;		/* The number of iterations taken */
long int nconv;
long int numop;		/* Number of OP*x operations */
long int numopb;		/* Number of B*x operations if BMAT='G' */
long int numreo;		/* Number of steps of re-orthogonalizations */
/* INTERNAL */
long int iparam[11];
long int ipntr[14];
} igraph_arpack_options_t;
```

This data structure contains the options of thee ARPACK eigenvalue solver routines. It must be initialized by calling `igraph_arpack_options_init()` on it. Then it can be used for multiple ARPACK calls, as the ARPACK solvers do not modify it. Input options:

Values:

`bmat`:

Character. Whether to solve a standard ('I') ot a generalized problem ('B').

`n`:

Dimension of the eigenproblem.

`which`:

Specifies which eigenvalues/vectors to compute. Possible values for symmetric matrices:

 `LA ` Compute `nev` largest (algebraic) eigenvalues. `SA ` Compute `nev` smallest (algebraic) eigenvalues. `LM ` Compute `nev` largest (in magnitude) eigenvalues. `SM ` Compute `nev` smallest (in magnitude) eigenvalues. `BE ` Compute `nev` eigenvalues, half from each end of the spectrum. When `nev` is odd, compute one more from the high en than from the low end.

Possible values for non-symmetric matrices:

 `LM ` Compute `nev` largest (in magnitude) eigenvalues. `SM ` Compute `nev` smallest (in magnitude) eigenvalues. `LR ` Compute `nev` eigenvalues of largest real part. `SR ` Compute `nev` eigenvalues of smallest real part. `LI ` Compute `nev` eigenvalues of largest imaginary part. `SI ` Compute `nev` eigenvalues of smallest imaginary part.

`nev`:

The number of eigenvalues to be computed.

`tol`:

Stopping criterion: the relative accuracy of the Ritz value is considered acceptable if its error is less than `tol` times its estimated value. If this is set to zero then machine precision is used.

`ncv`:

Number of Lanczos vectors to be generated.

`ldv`:

Numberic scalar. It should be set to zero in the current igraph implementation.

`ishift`:

Either zero or one. If zero then the shifts are provided by the user via reverse communication. If one then exact shifts with respect to the reduced tridiagonal matrix `T`. Please always set this to one.

`mxiter`:

Maximum number of Arnoldi update iterations allowed.

`nb`:

Blocksize to be used in the recurrence. Please always leave this on the default value, one.

`mode`:

The type of the eigenproblem to be solved. Possible values if the input matrix is symmetric:

1. A*x=lambda*x, A is symmetric.

2. A*x=lambda*M*x, A is symmetric, M is symmetric positive definite.

3. K*x=lambda*M*x, K is symmetric, M is symmetric positive semi-definite.

4. K*x=lambda*KG*x, K is symmetric positive semi-definite, KG is symmetric indefinite.

5. A*x=lambda*M*x, A is symmetric, M is symmetric positive semi-definite. (Cayley transformed mode.)

Please note that only `mode` ==1 was tested and other values might not work properly. Possible values if the input matrix is not symmetric:

1. A*x=lambda*x.

2. A*x=lambda*M*x, M is symmetric positive definite.

3. A*x=lambda*M*x, M is symmetric semi-definite.

4. A*x=lambda*M*x, M is symmetric semi-definite.

Please note that only `mode` == 1 was tested and other values might not work properly.

`start`:

Whether to use the supplied starting vector (1), or use a random starting vector (0). The starting vector must be supplied in the first column of the `vectors` argument of the `igraph_arpack_rssolve()` of `igraph_arpack_rnsolve()` call.

Output options:

Values:

`info`:

Error flag of ARPACK. Possible values:

 `0 ` Normal exit. `1 ` Maximum number of iterations taken. `3 ` No shifts could be applied during a cycle of the Implicitly restarted Arnoldi iteration. One possibility is to increase the size of \ ncv relative to `nev`.

ARPACK can return other error flags as well, but these are converted to igraph errors, see `igraph_error_type_t`.

`ierr`:

Error flag of the second ARPACK call (one eigenvalue computation usually involves two calls to ARPACK). This is always zero, as other error codes are converted to igraph errors.

`noiter`:

Number of Arnoldi iterations taken.

`nconv`:

Number of converged Ritz values. This represents the number of Ritz values that satisfy the convergence critetion.

`numop`:

Total number of matrix-vector multiplications.

`numopb`:

Not used currently.

`numreo`:

Total number of steps of re-orthogonalization.

Internal options:

Values:

 `lworkl`: Do not modify this option. `sigma`: Do not modify this option. `sigmai`: Do not modify this option. `iparam`: Do not modify this option. `ipntr`: Do not modify this option.