/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
|