This file is indexed.

/usr/include/CLHEP/GenericFunctions/DoubleParamToArgAdaptor.icc is in libclhep-dev 2.1.4.1+dfsg-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
// -*- C++ -*-
// $Id: DoubleParamToArgAdaptor.icc,v 1.2 2003/09/06 14:04:13 boudreau Exp $
#include "CLHEP/GenericFunctions/DoubleParamToArgAdaptor.hh"
#include <assert.h>
#include <iostream>

namespace Genfun {


//FUNCTION_OBJECT_IMP(DoubleParamToArgAdaptor) Do it by hand here:

template <class F>
FunctionComposition DoubleParamToArgAdaptor<F>::operator()(const AbsFunction & function) const
{                                            
  return AbsFunction::operator() (function); 
}     
                 
template <class F>                      
DoubleParamToArgAdaptor<F> *DoubleParamToArgAdaptor<F>::clone () const {       
  return (DoubleParamToArgAdaptor<F> *) _clone();             
}
                                            
template <class F>                      
AbsFunction *DoubleParamToArgAdaptor<F>::_clone () const {    
  return new DoubleParamToArgAdaptor<F>(*this);                       
}



template<class F> 
DoubleParamToArgAdaptor<F>::DoubleParamToArgAdaptor(const F        &function,
				        DoubleParamToArgAdaptor<F>::ScopedMethodPtr parameterFetchMethod0,
                                        DoubleParamToArgAdaptor<F>::ScopedMethodPtr parameterFetchMethod1):
  _scaleFactor0("Scale 0",  1.0,  0, 10),
  _scaleFactor1("Scale 1",  1.0,  0, 10),
  _function(function.clone()),
  _parameterFetchMethod0(parameterFetchMethod0),
  _parameterFetchMethod1(parameterFetchMethod1)
{
  _parameterFetchMethod0(*_function).setLowerLimit(-std::numeric_limits<double>::max());
  _parameterFetchMethod0(*_function).setUpperLimit(+std::numeric_limits<double>::max());
  _parameterFetchMethod1(*_function).setLowerLimit(-std::numeric_limits<double>::max());
  _parameterFetchMethod1(*_function).setUpperLimit(+std::numeric_limits<double>::max());
}

template <class F>
DoubleParamToArgAdaptor<F>::~DoubleParamToArgAdaptor() {
  delete _function;
}

template <class F>
DoubleParamToArgAdaptor<F>::DoubleParamToArgAdaptor(const DoubleParamToArgAdaptor & right):
  _scaleFactor0(right._scaleFactor0),
  _scaleFactor1(right._scaleFactor1),
  _parameterFetchMethod0(right._parameterFetchMethod0),
  _parameterFetchMethod1(right._parameterFetchMethod1),
  _function(right._function->clone())
{
  _parameterFetchMethod0(*_function).setLowerLimit(-std::numeric_limits<double>::max());
  _parameterFetchMethod0(*_function).setUpperLimit(+std::numeric_limits<double>::max());
  _parameterFetchMethod1(*_function).setLowerLimit(-std::numeric_limits<double>::max());
  _parameterFetchMethod1(*_function).setUpperLimit(+std::numeric_limits<double>::max());
}


template <class F>
double DoubleParamToArgAdaptor<F>::operator ()(double x) const
{
  std::cerr
    << "Warning.  DoubleParamToArgAdaptor called with scalar argument"
    << std::endl;
  assert(0);
  return 0;
}

template <class F>
Parameter & DoubleParamToArgAdaptor<F>::scaleFactor0() {
  return _scaleFactor0;
}

template <class F>
const Parameter & DoubleParamToArgAdaptor<F>::scaleFactor0() const {
  return _scaleFactor0;
}

template <class F>
Parameter & DoubleParamToArgAdaptor<F>::scaleFactor1() {
  return _scaleFactor1;
}

template <class F>
const Parameter & DoubleParamToArgAdaptor<F>::scaleFactor1() const {
  return _scaleFactor1;
}

template <class F>
unsigned int DoubleParamToArgAdaptor<F>::dimensionality() const {
  return _function->dimensionality()+1;
}

template <class F> 
double DoubleParamToArgAdaptor<F>::operator() (const Argument & a) const {
  if (dimensionality()!= a.dimension()) {
    std::cerr
      << "Warning: DoubleParamToArgAdaptor function/argument dimension mismatch"
      <<  std::endl;
    assert(0);
    return 0;
  }
  int dMinus = a.dimension()-1;
  Argument aPrime(dMinus);
  for (int i=0;i<dMinus;i++) aPrime[i]=a[i];
  (_parameterFetchMethod0(*_function)).setValue(_scaleFactor0.getValue()*a[dMinus]);
  (_parameterFetchMethod1(*_function)).setValue(_scaleFactor1.getValue()*a[dMinus]);
  return (*_function)(a);
}

} // end of namespace Genfun