This file is indexed.

/usr/include/adolc/sparse/sparsedrivers.h is in libadolc-dev 2.6.3-1.

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
/*----------------------------------------------------------------------------
 ADOL-C -- Automatic Differentiation by Overloading in C++
 File:     sparse/sparsedrivers.h
 Revision: $Id: sparsedrivers.h 585 2014-11-07 11:55:22Z kulshres $
 Contents: This file containts some "Easy To Use" interfaces of sparse package.
 
 Copyright (c) Andrea Walther

 This file is part of ADOL-C. This software is provided as open source.
 Any use, reproduction, or distribution of the software constitutes 
 recipient's acceptance of the terms of the accompanying license file.
 
----------------------------------------------------------------------------*/
#if !defined (ADOLC_SPARSE_SPARSE_H)
#define ADOLC_SPARSE_SPARSE_H 1

#include <adolc/internal/common.h>



BEGIN_C_DECLS



/****************************************************************************/


/*--------------------------------------------------------------------------*/
/*                                                         jacobian pattern */
/* jac_pat(tag, m, n, argument,                                             */
/*         crs[] [ crs[][0] = non-zero independent blocks per row ],        */
/*         options[3])                                                      */
/*                                                                          */

ADOLC_DLL_EXPORT int jac_pat
(short,int,int,const double*,unsigned int**,int*);

/*--------------------------------------------------------------------------*/
/*                                              abs-normal jacobian pattern */
/* absnormal_jac_pat(tag, m, n, s, argument,                                */
/*         crs[] [ crs[][0] = non-zero independent blocks per row ])        */
/*                                                                          */
ADOLC_DLL_EXPORT int absnormal_jac_pat
(short,int,int,int,const double*,unsigned int**);
/*--------------------------------------------------------------------------*/
/*                                         seed matrix for sparse jacobian  */
/* generate_seed_jac(m, n, crs, &seed, &p, option);                         */

ADOLC_DLL_EXPORT void generate_seed_jac
(int, int, unsigned int**, double***, int*, int);

/*--------------------------------------------------------------------------*/
/*                                                         sparse jacobian  */
/* int sparse_jac(tag, m, n, repeat, x, &nnz, &row_ind, &col_ind, &values,  */
/*                options[3]);                                              */

ADOLC_DLL_EXPORT int sparse_jac
(short, int , int, int, const double*, int *,
 unsigned int **, unsigned int **, double **,int*);


/*--------------------------------------------------------------------------*/
/*                                                          hessian pattern */
/* hess_pat(tag, n, x[n], crs[n][*], option)                                */
/*                                                                          */
/*     crs[i][ crs[i][0] = non-zero entries per row ]                       */
/*                                                                          */

ADOLC_DLL_EXPORT int hess_pat(short,int,const double*,unsigned int**, int);

/*--------------------------------------------------------------------------*/
/*                                          seed matrix for sparse hessian  */
/* generate_seed_hess(n, crs, &seed, &p, option);                           */

ADOLC_DLL_EXPORT void generate_seed_hess
(int, unsigned int**, double***, int*, int);

/*--------------------------------------------------------------------------*/
/*                                                          sparse hessian  */
/* int sparse_hess(tag, n, repeat, x, &nnz, &row_ind, &col_ind, &values,    */
/*                 options[2]);                                             */

ADOLC_DLL_EXPORT int sparse_hess
(short, int , int, const double*, int *,
 unsigned int **, unsigned int **, double **,int*);

ADOLC_DLL_EXPORT void set_HP(
    short          tag,        /* tape identification                     */
    int            indep,      /* number of independent variables         */
    unsigned int ** HP);

ADOLC_DLL_EXPORT void get_HP(
    short          tag,        /* tape identification                     */
    int            indep,      /* number of independent variables         */
    unsigned int *** HP);

/*--------------------------------------------------------------------------*/
/*                                                   JACOBIAN BLOCK PATTERN */

/* Max. number of unsigned ints to store the seed / jacobian matrix strips.
   Reduce this value to x if your system happens to run out of memory. 
   x < 10 makes no sense. x = 50 or 100 is better
   x stays for ( x * sizeof(unsigned long int) * 8 ) 
   (block) variables at once                                            */

#define PQ_STRIPMINE_MAX 30

ADOLC_DLL_EXPORT int bit_vector_propagation
(short, int, int, const double*, unsigned int**, int*);

/****************************************************************************/
END_C_DECLS

#endif