This file is indexed.

/usr/include/itsol/globheads.h is in libitsol-dev 1.0.0-3.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
#ifndef __VBLOCK_HEADER_H__
#define __VBLOCK_HEADER_H__

#define MAX_BLOCK_SIZE   100

/* FORTRAN style vblock format, compatible for many FORTRAN routines */
#define DATA(a,row,i,j)  (a[(j)*(row)+(i)])

/* the dimension of ith Block */
#define B_DIM(bs,i)      (bs[i+1]-bs[i])

typedef struct SpaFmt {
/*--------------------------------------------- 
| C-style CSR format - used internally
| for all matrices in CSR format 
|---------------------------------------------*/
  int n;
  int *nzcount;  /* length of each row */
  int **ja;     /* pointer-to-pointer to store column indices  */
  double **ma;  /* pointer-to-pointer to store nonzero entries */
} SparMat, *csptr;

typedef double *BData;

typedef struct VBSpaFmt {
    int n;        /* the block row dimension of the matrix      */
    int *bsz;     /* the row/col of the first element of each   */
                  /* diagonal block                             */
    int *nzcount;  /* length of each row                         */
    int **ja;     /* pointer-to-pointer to store column indices */
    BData **ba;   /* pointer-to-pointer to store nonzero blocks */
    BData *D;     /* to store inversion of diagonals            */
} VBSparMat, *vbsptr;

typedef struct VBILUfac {
    int n;
    int *bsz;     /* the row/col of the first element of each   */
                  /* diagonal block                             */

    BData *D;     /* diagonal blocks                            */
    vbsptr L;     /* L part blocks                              */
    vbsptr U;     /* U part blocks                              */
    int *work;    /* working buffer                             */
    BData bf;     /* buffer of a temp block                     */
    int DiagOpt;  /* Option for diagonal inversion/solutiob     */
                  /* opt =  1 -->> call luinv                   */
                  /* opt == 2 -->> block inverted call dgemv    */
} VBILUSpar, *vbiluptr; 

typedef struct ILUfac {
    int n;
    csptr L;      /* L part elements                            */
    double *D;    /* diagonal elements                          */
    csptr U;      /* U part elements                            */
    int *work;    /* working buffer */
} ILUSpar, LDUmat, *iluptr;


typedef struct PerMat4 *p4ptr;
typedef struct PerMat4 {
/*------------------------------------------------------------
| struct for storing the block LU factorization 
| contains all the block factors except the 
| data related to the last block. 
| n       = size of current block
| symperm = whether or not permutations are symmetric.
|           used only in cleanP4..
| nB      = size of B-block
| L, U    = ILU factors of B-block
| F, E    = sparse matrices in (1,2) and (2,1) 
|           parts of matrix. 
| perm    = (symmetric) permutation used in factorization
|           comes from the independent set ordering
| rperm   = unsymmetric permutation (rows) not used in this
|           version -- but left here for compatibility..
| D1, D2  = diagonal matrices (left, right) used for scaling
|           if scaling option is turned on. Note that the 
|           method works by scaling the whole matrix first
|           (at any level) before anything else is done. 
| wk     = a work vector of length n needed for various tasks
|            [reduces number of calls to malloc]           
|----------------------------------------------------------*/ 
  int n;                  
  int nB; 
  int symperm;
/*   LU factors  */
  struct SpaFmt *L;
  struct SpaFmt *U;
/* E, F blocks   */
  struct SpaFmt *E;
  struct SpaFmt *F;
  int *rperm;       /* row permutation         */ 
  int *perm;        /* col. permutation        */ 
  double *D1 ;      /* diagonal scaling row    */  
  double *D2 ;      /* diagonal scaling columns*/  
  double *wk;       /* work array              */
/* pointer to next and previous struct         */
  p4ptr prev; 
  p4ptr next;
} Per4Mat; 
/* -------------------------------------------------------------------*/
typedef struct ILUTfac *ilutptr;
typedef struct ILUTfac {
/*------------------------------------------------------------
| struct for storing data related to the last schur complement 
| we need to store the C matrix associated with the last block
| and the ILUT factorization of the related Schur complement.
| 
| n       = size of C block = size of Schur complement
| C       = C block of last level matrix. 
| L, U    = ILU factors of last schur complement. 
|
| meth[4] = parameters for defining variants in factorization 
|           - see function readin for details
| rperm    = row permutation used for very nonsymmetric matrices 
|            [such as bottleneck transversal] -- NOT IN THIS VERSION
| perm2     = unsymmetric permutation (columns) - used primarily
|           for the ILUTP version of ILUT/.. 
| D1, D2  = diagonal matrices (left, right) used for scaling
|           if scaling option is turned on. Note that the 
|           method works by scaling the whole matrix first
|           (at any level) before anything else is done. 
| wk     = a work vector of length n needed for various tasks
|            [reduces number of calls to malloc]           
|-----------------------------------------------------------*/
   int n;                  
 /*-------------------- C matrix of last block */
   struct SpaFmt *C;
  /* LU factorization       */
   struct SpaFmt *L;
   struct SpaFmt *U;
 /*--------------------  related to variants and methods */
 /*    int meth[4];   */
  int *rperm;   /* row single-sinded permutation */
  int *perm;    /* column perm .                */
  int *perm2;   /* column permutation coming from pivoting in ILU */ 
   double *D1;
   double *D2;
   double *wk;
} IluSpar;

typedef struct arms_st *arms;
typedef struct arms_st {
  /* this is the arms preconditioner struct 
  | it consists of a linked list of p4mat structs
  | and the ILUt factorization (in the  form of an 
  | IluSpar struct  
  |---------------------------------------------- */
  int n;                   /* dimension of matrix */
  int nlev;                /* number of levels    */
  ilutptr ilus;            /* ILU for last level  */
  p4ptr levmat;            /* level structure     */
} armsMat;

typedef struct __CompressType
{
  int grp;   /* -1: begin new group, >=0: belong to grp-th row */
  int count; /* block size, valid only if grp = -1 */
} CompressType;

typedef struct _SMat {
  /*-------------------- 3 types of matrices so far */
  int n; 
  int Mtype;           /*--  type 1 = CSR, 2 = VBCSR, 3 = LDU    */
  csptr CSR;           /* place holder for a CSR/CSC type matrix */
  iluptr LDU;          /* struct for an LDU type matrix          */
  vbsptr VBCSR;        /* place holder for a block matrix        */
  void (*matvec)(struct _SMat*, double *, double *);
} SMat, *SMatptr;

typedef struct _SPre {
  /*-------------------- 3 types of matrices so far */
  int Ptype;           /*-- Ptype 1 = ILU, 2 = VBILU, 3 = Crout */
  iluptr   ILU;        /* struct for an ILU type preconditioner */
  vbiluptr VBILU;      /* struct for a block     preconditioner */
  arms ARMS;           /* struct for a block     preconditioner */
  int (*precon) (double *, double *, struct _SPre*); 
} SPre, *SPreptr;
  

#endif  /* __VBLOCK_HEADER_H__ */