This file is indexed.

/usr/include/CLHEP/Random/RandGeneral.h is in libclhep-dev 2.1.2.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
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
// $Id: RandGeneral.h,v 1.5 2010/06/16 17:24:53 garren Exp $
// -*- C++ -*-
//
// -----------------------------------------------------------------------
//                             HEP Random
//                          --- RandGeneral ---
//                          class header file
// -----------------------------------------------------------------------

// Class defining methods for shooting generally distributed random values,
// given a user-defined probability distribution function.

// =======================================================================
// S.Magni & G.Pieri  - Created: 29 April 1998 
// G.Cosmo            - Added constructor using default engine from the
//                     	static generator: 20 Aug 1998
// S.Magni & G.Pieri  - Added linear interpolation: 24 March 1999
// M. Fischler	      - Added private methods that simplify the implementaion
// 			prepareTables(), useFlatDistribution(), mapRandom()
//		      - Added private variable oneOverNbins.
//	     	      - Made the warning about shoot() not being static a tad
//			more prominent.   		14 May 1999	
// M Fischler         - put and get to/from streams 12/15/04
// =======================================================================

#ifndef RandGeneral_h
#define RandGeneral_h 1

#include "CLHEP/Random/defs.h"
#include "CLHEP/Random/Random.h"
#include "CLHEP/Utility/memory.h"
#include <vector>

namespace CLHEP {

/**
 * @author
 * @ingroup random
 */
class RandGeneral : public HepRandom {

public:

  RandGeneral ( const double* aProbFunc, 
		int theProbSize, 
		int IntType=0 );
  RandGeneral ( HepRandomEngine& anEngine,
                const double* aProbFunc, 
		int theProbSize, 
		int IntType=0 );
  RandGeneral ( HepRandomEngine* anEngine, 
                const double* aProbFunc, 
		int theProbSize, 
		int IntType=0 );
  // These constructors should be used to instantiate a RandGeneral
  // distribution object defining a local engine for it.
  // The static generator will be skipped by using the non-static methods
  // defined below. In case no engine is specified in the constructor, the
  // default engine used by the static generator is applied.
  // If the engine is passed by pointer the corresponding engine object
  // will be deleted by the RandGeneral destructor.
  // If the engine is passed by reference the corresponding engine object
  // will not be deleted by the RandGeneral destructor.
  // The probability distribution function (Pdf) must be provided by the user
  // as an array of positive real number. The array size must also be
  // provided. The Pdf doesn't need to be normalized to 1. 
  // if IntType = 0 ( default value ) a uniform random number is
  // generated using the engine. The uniform number is then transformed
  // to the user's distribution using the cumulative probability
  // distribution constructed from his histogram. The cumulative
  // distribution is inverted using a binary search for the nearest
  // bin boundary and a linear interpolation within the
  // bin. RandGeneral therefore generates a constant density within
  // each bin.
  // if IntType = 1 no interpolation is performed and the result is a
  // discrete distribution.

  virtual ~RandGeneral();
  // Destructor

  // Methods to shoot random values using the static generator
  // N.B.: The methods are NOT static since they use nonstatic members
  // theIntegralPdf & nBins

	/////////////////////
	//		   //
	// BIG RED WARNING //
	//		   //
	/////////////////////
	//
	// The above N.B. is telling users that the shoot() methods in this
	// class are NOT STATIC.  You cannot do 
	//	double x = RandGeneral::shoot();
	// It would not make sense to provide a static shoot -- what would 
	// the default probability function look like?

  inline double shoot();

  inline void shootArray ( const int size, double* vect);

  //  Methods to shoot random values using a given engine
  //  by-passing the static generator.

  double shoot( HepRandomEngine* anEngine );

  void shootArray ( HepRandomEngine* anEngine, const int size,
                    double* vect );
			    
  //  Methods using the localEngine to shoot random values, by-passing
  //  the static generator.

  double fire();

  void fireArray ( const int size, double* vect);

  double operator()();

  // Save and restore to/from streams
  
  std::ostream & put ( std::ostream & os ) const;
  std::istream & get ( std::istream & is );

  std::string name() const;
  HepRandomEngine & engine();

  static std::string distributionName() {return "RandGeneral";}  
  // Provides the name of this distribution class
  

private:

  shared_ptr<HepRandomEngine> localEngine;
  std::vector<double> theIntegralPdf;
  int nBins;
  double oneOverNbins;
  int InterpolationType;

  // Private methods to factor out replicated implementation sections
  void prepareTable(const double* aProbFunc);
  void useFlatDistribution();
  double mapRandom(double rand) const;

};

}  // namespace CLHEP

#ifdef ENABLE_BACKWARDS_COMPATIBILITY
//  backwards compatibility will be enabled ONLY in CLHEP 1.9
using namespace CLHEP;
#endif

#include "CLHEP/Random/RandGeneral.icc"

#endif