CMS 3D CMS Logo
Namespaces | Classes | Typedefs | Functions

npstat Namespace Reference

Namespaces

namespace  Private

Classes

struct  AbsArrayProjector
struct  AbsMultivariateFunctor
struct  AbsVisitor
struct  addmul_left
struct  addmul_right
class  ArrayND
class  ArrayNDScanner
struct  ArrayRange
struct  assign_left
struct  assign_right
struct  BoxND
class  BoxNDScanner
struct  CastingCopyConstructor
class  CircularMapper1d
struct  ComplexComparesAbs
struct  ComplexComparesAbs< std::complex< T > >
struct  ComplexComparesFalse
struct  ComplexComparesFalse< std::complex< T > >
class  CoordinateSelector
struct  DefaultConstructor0
struct  DefaultConstructor1
struct  DefaultConstructor2
struct  DefaultConstructor3
struct  diveq_left
struct  diveq_left_0by0isC
struct  diveq_right
struct  diveq_right_0by0isC
class  DualAxis
class  DualHistoAxis
struct  Element1D
struct  Element1DAt
class  EquidistantInLinearSpace
class  EquidistantInLogSpace
struct  FcnFunctor0
struct  FcnFunctor1
struct  FcnFunctor2
struct  FcnFunctor3
struct  Functor0
struct  Functor1
struct  Functor2
struct  Functor3
class  GridAxis
class  HistoAxis
class  HistoND
class  Interval
class  LinearMapper1d
class  LinInterpolatedTableND
struct  minuseq_left
struct  minuseq_right
struct  multeq_left
struct  multeq_right
class  MultivariateFunctorScanner
struct  NpstatDomainError
struct  NpstatException
struct  NpstatInvalidArgument
struct  NpstatOutOfRange
struct  NpstatRuntimeError
class  NUHistoAxis
struct  pluseq_left
struct  pluseq_right
struct  PreciseType
struct  PreciseType< const std::complex< T > >
struct  PreciseType< const volatile std::complex< T > >
struct  PreciseType< std::complex< T > >
struct  PreciseType< volatile std::complex< T > >
struct  PreciseTypeHelper
struct  PreciseTypeHelper< T, 1 >
struct  ProperDblFromCmpl
struct  ProperDblFromCmpl< const std::complex< T > >
struct  ProperDblFromCmpl< const volatile std::complex< T > >
struct  ProperDblFromCmpl< std::complex< T > >
struct  ProperDblFromCmpl< volatile std::complex< T > >
struct  Same
struct  SameRef
struct  scast_assign_left
struct  scast_assign_right
struct  scast_minuseq_left
struct  scast_minuseq_right
struct  scast_pluseq_left
struct  scast_pluseq_right
class  StorableHistoNDFunctor
class  StorableInterpolationFunctor
class  StorableMultivariateFunctor
class  StorableMultivariateFunctorReader
class  UniformAxis
class  VisitCounter

Typedefs

typedef std::vector< unsigned > ArrayShape
typedef StorableHistoNDFunctor
< double, DualHistoAxis > 		DoubleHistoNDFunctor
typedef
StorableInterpolationFunctor
< double, DualAxis > 		DoubleInterpolationFunctor
typedef StorableHistoNDFunctor
< double, NUHistoAxis > 		DoubleNUHistoNDFunctor
typedef
StorableInterpolationFunctor
< double, GridAxis > 		DoubleNUInterpolationFunctor
typedef StorableHistoNDFunctor
< double, HistoAxis > 		DoubleUAHistoNDFunctor
typedef
StorableInterpolationFunctor
< double, UniformAxis > 		DoubleUAInterpolationFunctor
typedef StorableHistoNDFunctor
< float, DualHistoAxis > 		FloatHistoNDFunctor
typedef
StorableInterpolationFunctor
< float, DualAxis > 		FloatInterpolationFunctor
typedef StorableHistoNDFunctor
< float, NUHistoAxis > 		FloatNUHistoNDFunctor
typedef
StorableInterpolationFunctor
< float, GridAxis > 		FloatNUInterpolationFunctor
typedef StorableHistoNDFunctor
< float, HistoAxis > 		FloatUAHistoNDFunctor
typedef
StorableInterpolationFunctor
< float, UniformAxis > 		FloatUAInterpolationFunctor
typedef gs::StaticReader
< StorableMultivariateFunctorReader > 		StaticStorableMultivariateFunctorReader

Functions

template<typename T >
Private::AbsReturnType< T >::type absDifference (const T &v1, const T &v2)
template<typename T >
Private::AbsReturnType< T >::type absValue (const T &v1)
template<typename T >
void clearBuffer (T *buf, const unsigned long len)
bool closeWithinTolerance (const double &a, const double &b, const double &tol)
template<typename Histo >
void convertHistoToDensity (Histo *histogram, bool knownNonNegative=false)
UniformAxis convertToGridAxis (const HistoAxis &histoAxis)
GridAxis convertToGridAxis (const NUHistoAxis &histoAxis)
NUHistoAxis convertToHistoAxis (const GridAxis &gridAxis, double xMin)
HistoAxis convertToHistoAxis (const UniformAxis &gridAxis)
template<typename Histo >
std::vector< CircularMapper1d > convolutionHistoMap (const Histo &histo, bool doubleDataRange)
template<typename T1 , typename T2 >
void copyBuffer (T1 *dest, const T2 *source, const unsigned long len)
template<typename Histo >
std::vector< LinearMapper1d > densityScanHistoMap (const Histo &histo)
template<typename T >
void destroyBuffer (T *thisBuffer, const T *stackBuffer)
ArrayShape doubleShape (const ArrayShape &inputShape)
ArrayShape halfShape (const ArrayShape &inputShape)
template<typename T >
T interpolate_cubic (const double x, const T &f0, const T &f1, const T &f2, const T &f3)
template<typename T >
T interpolate_linear (const double x, const T &f0, const T &f1)
template<typename T >
T interpolate_quadratic (const double x, const T &f0, const T &f1, const T &f2)
template<typename Float , class Axis >
Float interpolateHistoND (const HistoND< Float, Axis > &histo, const double *coords, unsigned coordsDim, unsigned interpolationDegree)
template<class Iter >
bool isMonotonous (Iter const begin, Iter const end)
template<class Iter >
bool isNonDecreasing (Iter begin, Iter const end)
template<class Iter >
bool isNonIncreasing (Iter begin, Iter const end)
template<class Iter >
bool isStrictlyDecreasing (Iter begin, Iter const end)
template<class Iter >
bool isStrictlyIncreasing (Iter begin, Iter const end)
template<class Iter >
bool isStrictlyMonotonous (Iter const begin, Iter const end)
bool isSubShape (const ArrayShape &sh1, const ArrayShape &sh2)
template<typename T >
T * makeBuffer (unsigned sizeNeeded, T *stackBuffer, unsigned sizeofStackBuffer)
 me_macro_check_loop_prerequisites (jointSubrangeScan, commonSubrangeLoop) me_macro_check_loop_prerequisites(dualCircularScan
dualCircularLoop me_macro_check_loop_prerequisites (flatCircularScan, flatCircularLoop) me_macro_check_loop_prerequisites(circularFlatScan
template<typename Num1 , unsigned Len1, unsigned Dim1, typename Num2 , unsigned Len2, unsigned Dim2>
void rescanArray (const ArrayND< Num1, Len1, Dim1 > &from, ArrayND< Num2, Len2, Dim2 > *to, unsigned interpolationDegree=0)
ArrayShape makeShape ()
ArrayShape makeShape (unsigned i0)
ArrayShape makeShape (unsigned i0, unsigned i1)
ArrayShape makeShape (unsigned i0, unsigned i1, unsigned i2)
ArrayShape makeShape (unsigned i0, unsigned i1, unsigned i2, unsigned i3)
ArrayShape makeShape (unsigned i0, unsigned i1, unsigned i2, unsigned i3, unsigned i4)
ArrayShape makeShape (unsigned i0, unsigned i1, unsigned i2, unsigned i3, unsigned i4, unsigned i5)
ArrayShape makeShape (unsigned i0, unsigned i1, unsigned i2, unsigned i3, unsigned i4, unsigned i5, unsigned i6)
ArrayShape makeShape (unsigned i0, unsigned i1, unsigned i2, unsigned i3, unsigned i4, unsigned i5, unsigned i6, unsigned i7)
ArrayShape makeShape (unsigned i0, unsigned i1, unsigned i2, unsigned i3, unsigned i4, unsigned i5, unsigned i6, unsigned i7, unsigned i8)
ArrayShape makeShape (unsigned i0, unsigned i1, unsigned i2, unsigned i3, unsigned i4, unsigned i5, unsigned i6, unsigned i7, unsigned i8, unsigned i9)
ArrayShape makeShape (const unsigned *indices, unsigned nIndices)
template<typename T >
unsigned interpolation_coefficients (T *buffer, unsigned bufLen, const T &f0, const T &f1)
template<typename T >
unsigned interpolation_coefficients (T *buffer, unsigned bufLen, const T &f0, const T &f1, const T &f2)
template<typename T >
unsigned interpolation_coefficients (T *buffer, unsigned bufLen, const T &f0, const T &f1, const T &f2, const T &f3)
template<typename Float , class Axis >
Float interpolateHistoND (const HistoND< Float, Axis > &histo, double x0, unsigned interpolationDegree)
template<typename Float , class Axis >
Float interpolateHistoND (const HistoND< Float, Axis > &histo, double x0, double x1, unsigned interpolationDegree)
template<typename Float , class Axis >
Float interpolateHistoND (const HistoND< Float, Axis > &histo, double x0, double x1, double x2, unsigned interpolationDegree)
template<typename Float , class Axis >
Float interpolateHistoND (const HistoND< Float, Axis > &histo, double x0, double x1, double x2, double x3, unsigned interpolationDegree)
template<typename Float , class Axis >
Float interpolateHistoND (const HistoND< Float, Axis > &histo, double x0, double x1, double x2, double x3, double x4, unsigned interpolationDegree)
template<typename Float , class Axis >
Float interpolateHistoND (const HistoND< Float, Axis > &histo, double x0, double x1, double x2, double x3, double x4, double x5, unsigned interpolationDegree)
template<typename Float , class Axis >
Float interpolateHistoND (const HistoND< Float, Axis > &histo, double x0, double x1, double x2, double x3, double x4, double x5, double x6, unsigned interpolationDegree)
template<typename Float , class Axis >
Float interpolateHistoND (const HistoND< Float, Axis > &histo, double x0, double x1, double x2, double x3, double x4, double x5, double x6, double x7, unsigned interpolationDegree)
template<typename Float , class Axis >
Float interpolateHistoND (const HistoND< Float, Axis > &histo, double x0, double x1, double x2, double x3, double x4, double x5, double x6, double x7, double x8, unsigned interpolationDegree)
template<typename Float , class Axis >
Float interpolateHistoND (const HistoND< Float, Axis > &histo, double x0, double x1, double x2, double x3, double x4, double x5, double x6, double x7, double x8, double x9, unsigned interpolationDegree)

Typedef Documentation

typedef std::vector<unsigned> npstat::ArrayShape

This type will be used to specify array length in each dimension

Definition at line 21 of file ArrayShape.h.

typedef StorableHistoNDFunctor<double,DualHistoAxis> npstat::DoubleHistoNDFunctor

Definition at line 18 of file HistoNDFunctorInstances.h.

typedef StorableInterpolationFunctor<double,DualAxis> npstat::DoubleInterpolationFunctor

Definition at line 20 of file InterpolationFunctorInstances.h.

typedef StorableHistoNDFunctor<double,NUHistoAxis> npstat::DoubleNUHistoNDFunctor

Definition at line 22 of file HistoNDFunctorInstances.h.

typedef StorableInterpolationFunctor<double,GridAxis> npstat::DoubleNUInterpolationFunctor

Definition at line 26 of file InterpolationFunctorInstances.h.

typedef StorableHistoNDFunctor<double,HistoAxis> npstat::DoubleUAHistoNDFunctor

Definition at line 20 of file HistoNDFunctorInstances.h.

typedef StorableInterpolationFunctor<double,UniformAxis> npstat::DoubleUAInterpolationFunctor

Definition at line 23 of file InterpolationFunctorInstances.h.

typedef StorableHistoNDFunctor<float,DualHistoAxis> npstat::FloatHistoNDFunctor

Definition at line 24 of file HistoNDFunctorInstances.h.

typedef StorableInterpolationFunctor<float,DualAxis> npstat::FloatInterpolationFunctor

Definition at line 29 of file InterpolationFunctorInstances.h.

typedef StorableHistoNDFunctor<float,NUHistoAxis> npstat::FloatNUHistoNDFunctor

Definition at line 28 of file HistoNDFunctorInstances.h.

typedef StorableInterpolationFunctor<float,GridAxis> npstat::FloatNUInterpolationFunctor

Definition at line 35 of file InterpolationFunctorInstances.h.

typedef StorableHistoNDFunctor<float,HistoAxis> npstat::FloatUAHistoNDFunctor

Definition at line 26 of file HistoNDFunctorInstances.h.

typedef StorableInterpolationFunctor<float,UniformAxis> npstat::FloatUAInterpolationFunctor

Definition at line 32 of file InterpolationFunctorInstances.h.

typedef gs::StaticReader<StorableMultivariateFunctorReader> npstat::StaticStorableMultivariateFunctorReader

The reader factory for descendants of StorableMultivariateFunctor

Definition at line 33 of file StorableMultivariateFunctorReader.h.

Function Documentation

template<typename T >
Private::AbsReturnType<T>::type npstat::absDifference ( const T &  v1,
const T &  v2 
) [inline]

Absolute value of the difference between two numbers. Works for all standard numeric types, including unsigned and complex.

Definition at line 85 of file absDifference.h.

References delta.

Referenced by npstat::ArrayND< Numeric, StackLen, StackDim >::isClose(), npstat::ArrayND< Numeric, StackLen, StackDim >::makeCopulaSteps(), and npstat::ArrayND< Numeric, StackLen, StackDim >::maxAbsDifference().

    {
        return Private::AbsHelper<T,gs::IOIsUnsigned<T>::value>::delta(v1, v2);
    }
template<typename T >
Private::AbsReturnType<T>::type npstat::absValue ( const T &  v1) [inline]

Absolute value of a number. Works for all standard numeric types, including unsigned and complex.

Definition at line 96 of file absDifference.h.

References relativeConstraints::value.

Referenced by npstat::ArrayND< Numeric, StackLen, StackDim >::sumsq().

    {
        return Private::AbsHelper<T,gs::IOIsUnsigned<T>::value>::value(v1);
    }
template<typename T >
void npstat::clearBuffer ( T *  buf,
const unsigned long  len 
) [inline]

Clear a buffer (set all elements to the value produced by the default constructor)

Definition at line 57 of file allocators.h.

References i, and zero.

Referenced by npstat::ArrayND< Numeric, StackLen, StackDim >::ArrayND(), npstat::ArrayND< Numeric, StackLen, StackDim >::exportSubrange(), npstat::ArrayND< Numeric, StackLen, StackDim >::importSubrange(), and npstat::ArrayND< Numeric, StackLen, StackDim >::rotate().

    {
        if (len)
        {
            assert(buf);
            const T zero = T();
            for (unsigned long i=0; i<len; ++i)
                *buf++ = zero;
        }
    }
bool npstat::closeWithinTolerance ( const double &  a,
const double &  b,
const double &  tol 
) [inline]

Check if two doubles are within certain relative tolerance from each other. The "tol" argument which specifies the tolerance must be non-negative.

Definition at line 25 of file closeWithinTolerance.h.

References max().

Referenced by npstat::NUHistoAxis::isClose(), npstat::GridAxis::isClose(), npstat::UniformAxis::isClose(), and npstat::HistoAxis::isClose().

    {
        if (tol < 0.0)
            throw npstat::NpstatInvalidArgument("In npstat::closeWithinTolerance: "
                                        "negative tolerance is not allowed");
        if (a == b)
            return true;
        else
            return fabs(a - b)/std::max(fabs(a), fabs(b)) <= tol;
    }
template<typename Histo >
void npstat::convertHistoToDensity ( Histo *  histogram,
bool  knownNonNegative = false 
)

Reset negative histogram bins to zero and then divide histogram bin contents by the histogram integral. If the "knownNonNegative" argument is true, it will be assumed that there are no negative bins, and their explicit reset is unnecessary.

This function will throw npstat::NpstatRuntimeError in case the histogram is empty after all negative bins are reset.

This function is not a member of the HistoND class itself because these operations do not necessarily make sense for all bin types. Making such operation a member would make creation of HistoND scripting API (e.g., for python) more difficult.

Definition at line 3517 of file HistoND.h.

    {
        assert(h);
        if (!knownNonNegative)
            (const_cast<ArrayND<typename 
                Histo::value_type>&>(h->binContents())).makeNonNegative();
        const double integ = h->integral();
        *h /= integ;
    }
UniformAxis npstat::convertToGridAxis ( const HistoAxis &  histoAxis)

Convert uniform histogram to uniform grid axis axis

Definition at line 16 of file convertAxis.cc.

References lumiQTWidget::ax, npstat::HistoAxis::binCenter(), npstat::HistoAxis::label(), npstat::HistoAxis::nBins(), SiStripMonitorClusterAlca_cfi::xmax, and SiStripMonitorClusterAlca_cfi::xmin.

    {
        const unsigned nBins = histoAxis.nBins();
        const double xmin = histoAxis.binCenter(0);
        const double xmax = histoAxis.binCenter(nBins - 1);
        UniformAxis ax(nBins, xmin, xmax, histoAxis.label().c_str());
        return ax;
    }
GridAxis npstat::convertToGridAxis ( const NUHistoAxis &  histoAxis)

Note that conversion from non-uniform histogram axis into the grid axis is always possible, but it is loosing information (we are writing the positions of bin centers only, not edges)

Definition at line 45 of file convertAxis.cc.

References lumiQTWidget::ax, npstat::NUHistoAxis::binCenter(), i, npstat::NUHistoAxis::label(), and npstat::NUHistoAxis::nBins().

    {
        const unsigned nBins = histoAxis.nBins();
        std::vector<double> coords;
        coords.reserve(nBins);
        for (unsigned i=0; i<nBins; ++i)
            coords.push_back(histoAxis.binCenter(i));
        GridAxis ax(coords, histoAxis.label().c_str());
        return ax;
    }
HistoAxis npstat::convertToHistoAxis ( const UniformAxis &  gridAxis)

Convert uniform grid axis to uniform histogram axis

Definition at line 6 of file convertAxis.cc.

References lumiQTWidget::ax, npstat::UniformAxis::label(), npstat::UniformAxis::max(), npstat::UniformAxis::min(), npstat::UniformAxis::nCoords(), SiStripMonitorClusterAlca_cfi::xmax, and SiStripMonitorClusterAlca_cfi::xmin.

    {
        const unsigned nBins = gridAxis.nCoords();
        const double xmin = gridAxis.min();
        const double xmax = gridAxis.max();
        const double hbw = 0.5*(xmax - xmin)/(nBins - 1U);
        HistoAxis ax(nBins, xmin-hbw, xmax+hbw, gridAxis.label().c_str());
        return ax;
    }
NUHistoAxis npstat::convertToHistoAxis ( const GridAxis &  gridAxis,
double  xMin 
)

The conversion from non-uniform grid axis to non-uniform histogram axis is only unambiguous when some additional info is available. Here, in particular, we are asking for the position of the axis minimum. This function will throw npstat::NpstatInvalidArgument in case the conversion is impossible.

Definition at line 25 of file convertAxis.cc.

References lumiQTWidget::ax, npstat::GridAxis::coordinate(), i, npstat::GridAxis::label(), npstat::GridAxis::nCoords(), and x.

    {
        const unsigned nCoords = gridAxis.nCoords();
        std::vector<double> binEdges;
        binEdges.reserve(nCoords + 1U);
        binEdges.push_back(xMin);
        for (unsigned i=0; i<nCoords; ++i)
        {
            const double x = gridAxis.coordinate(i);
            if (x <= xMin)
                throw npstat::NpstatInvalidArgument("In npstat::convertToHistoAxis: "
                                            "conversion is impossible");
            const double halfbin = x - xMin;
            xMin = x + halfbin;
            binEdges.push_back(xMin);
        }
        NUHistoAxis ax(binEdges, gridAxis.label().c_str());
        return ax;
    }
template<typename Histo >
std::vector< CircularMapper1d > npstat::convolutionHistoMap ( const Histo &  histo,
bool  doubleDataRange 
)

Generate a density scanning map for subsequent use with the "DensityScanND" template when a density is to be convolved with the histogram data. Only histograms with uniform binning can be used here.

The "doubleDataRange" should be set "true" in case the data will be mirrored (or just empty range added) to avoid circular spilling after convolution.

Definition at line 3542 of file HistoND.h.

References i, and query::result.

    {
        std::vector<CircularMapper1d> result;
        const unsigned d = histo.dim();
        result.reserve(d);
        for (unsigned i=0; i<d; ++i)
            result.push_back(histo.axis(i).kernelScanMapper(doubleRange));
        return result;
    }
template<typename T1 , typename T2 >
void npstat::copyBuffer ( T1 *  dest,
const T2 *  source,
const unsigned long  len 
) [inline]

Copy a buffer (with possible type conversion on the fly)

Definition at line 41 of file allocators.h.

References i.

Referenced by npstat::ArrayND< Numeric, StackLen, StackDim >::ArrayND(), npstat::ArrayND< Numeric, StackLen, StackDim >::dot(), npstat::ArrayND< Numeric, StackLen, StackDim >::operator=(), npstat::ArrayND< Numeric, StackLen, StackDim >::setData(), and npstat::ArrayND< Numeric, StackLen, StackDim >::transpose().

    {
        if (len)
        {
            assert(dest);
            assert(source);
            for (unsigned long i=0; i<len; ++i)
                *dest++ = static_cast<T1>(*source++);
        }
    }
template<typename Histo >
std::vector< LinearMapper1d > npstat::densityScanHistoMap ( const Histo &  histo)

Generate a density scanning map for subsequent use with the "DensityScanND" template. Naturally, only histograms with uniform binning can be used here.

Definition at line 3528 of file HistoND.h.

References i, npstat::LinearMapper1d::inverse(), m, and query::result.

    {
        std::vector<LinearMapper1d> result;
        const unsigned d = histo.dim();
        result.reserve(d);
        for (unsigned i=0; i<d; ++i)
        {
            const LinearMapper1d& m = histo.axis(i).binNumberMapper(false);
            result.push_back(m.inverse());
        }
        return result;
    }
template<typename T >
void npstat::destroyBuffer ( T *  thisBuffer,
const T *  stackBuffer 
) [inline]

Function for freeing memory buffers allocated by "makeBuffer"

Definition at line 33 of file allocators.h.

Referenced by npstat::ArrayND< Numeric, StackLen, StackDim >::addToProjection(), npstat::ArrayND< Numeric, StackLen, StackDim >::contract(), npstat::ArrayND< Numeric, StackLen, StackDim >::dot(), npstat::ArrayND< Numeric, StackLen, StackDim >::functorFill(), npstat::ArrayND< Numeric, StackLen, StackDim >::processSubrange(), npstat::ArrayND< Numeric, StackLen, StackDim >::project(), npstat::ArrayND< Numeric, StackLen, StackDim >::subtractFromProjection(), npstat::ArrayND< Numeric, StackLen, StackDim >::transpose(), npstat::ArrayND< Numeric, StackLen, StackDim >::uninitialize(), and npstat::ArrayND< Numeric, StackLen, StackDim >::~ArrayND().

    {
        if (thisBuffer != stackBuffer)
            delete [] thisBuffer;
    }
ArrayShape npstat::doubleShape ( const ArrayShape &  inputShape)

Multiply the sise in each dimension by 2

Definition at line 155 of file ArrayShape.cc.

References i, and alignCSCRings::s.

Referenced by npstat::ArrayND< Numeric, StackLen, StackDim >::multiMirror().

    {
        ArrayShape s(inputShape);
        const unsigned len = s.size();
        for (unsigned i=0; i<len; ++i)
            s[i] *= 2U;
        return s;
    }
ArrayShape npstat::halfShape ( const ArrayShape &  inputShape)

Divide the size in each dimension by 2 (generate dynamic fault if odd)

Definition at line 164 of file ArrayShape.cc.

References i, and alignCSCRings::s.

    {
        ArrayShape s(inputShape);
        const unsigned len = s.size();
        for (unsigned i=0; i<len; ++i)
        {
            if (!(s[i] % 2U == 0)) throw npstat::NpstatInvalidArgument(
                "In npstat::halfShape: array span must be "
                "even in each dimension");
            s[i] /= 2U;
        }
        return s;
    }
template<typename T >
T npstat::interpolate_cubic ( const double  x,
const T &  f0,
const T &  f1,
const T &  f2,
const T &  f3 
) [inline]

Cubic interpolation. Assume that the function values are given at 0, 1, 2, and 3.

Definition at line 47 of file interpolate.h.

References interpolate_linear().

Referenced by npstat::ArrayND< Numeric, StackLen, StackDim >::interpolateLoop().

    {
        return interpolate_linear(x*(3.0 - x)/2.0,
                                  interpolate_linear(x/3.0, f0, f3),
                                  interpolate_linear(x - 1.0, f1, f2));
    }
template<typename T >
T npstat::interpolate_linear ( const double  x,
const T &  f0,
const T &  f1 
) [inline]

Linear interpolation. Assumes that the function values are given at 0 and 1.

Definition at line 23 of file interpolate.h.

References x.

Referenced by interpolate_cubic(), and npstat::ArrayND< Numeric, StackLen, StackDim >::interpolateLoop().

    {
        const typename ProperDblFromCmpl<T>::type dx = 1.0 - x;
        return f0*dx + f1*static_cast<typename ProperDblFromCmpl<T>::type>(x);
    }
template<typename T >
T npstat::interpolate_quadratic ( const double  x,
const T &  f0,
const T &  f1,
const T &  f2 
) [inline]

Quadratic interpolation. Assume that the function values are given at 0, 1, and 2.

Definition at line 34 of file interpolate.h.

References python::connectstrParser::f1.

Referenced by npstat::ArrayND< Numeric, StackLen, StackDim >::interpolateLoop().

    {
        static const typename ProperDblFromCmpl<T>::type two = 2.0;
        const typename ProperDblFromCmpl<T>::type dx = x - 1.0;
        return f1 + ((f2 - f0)/two + ((f2 - f1) + (f0 - f1))*(dx/two))*dx;
    }
template<typename Float , class Axis >
Float npstat::interpolateHistoND ( const HistoND< Float, Axis > &  histo,
const double *  coords,
unsigned  coordsDim,
unsigned  interpolationDegree 
)

The interpolation degree in this method can be set to 0, 1, or 3 which results, respectively, in closest bin lookup, multilinear interpolation, or multicubic interpolation. Value of the closest bin inside the histogram range is used if some coordinate is outside of the corresponding axis limits.

Definition at line 129 of file interpolateHistoND.h.

References lumiQTWidget::ax, npstat::HistoND< Numeric, Axis >::axes(), npstat::HistoND< Numeric, Axis >::binContents(), i, npstat::Private::iHND_checkArgs(), and npstat::ArrayND< Numeric, StackLen, StackDim >::interpolate1().

Referenced by npstat::StorableHistoNDFunctor< Numeric, Axis, Converter >::operator()().

    {
        Private::iHND_checkArgs(histo, xDim, interpolationDegree);
        assert(x);
        const Axis* ax = &histo.axes()[0];
        double coords[CHAR_BIT*sizeof(unsigned long)];
        for (unsigned i=0; i<xDim; ++i)
            coords[i] = ax[i].fltBinNumber(x[i], false);
        const ArrayND<Float>& bins(histo.binContents());
        switch (interpolationDegree)
        {
        case 1U:
            return bins.interpolate1(coords, xDim);
        case 3U:
            return bins.interpolate3(coords, xDim);
        default:
            return bins.closest(coords, xDim);
        }        
    }
template<typename Float , class Axis >
Float npstat::interpolateHistoND ( const HistoND< Float, Axis > &  histo,
double  x0,
unsigned  interpolationDegree 
)

Convenience function for interpolating histograms, with an explicit coordinate argument for each histogram dimension

Definition at line 152 of file interpolateHistoND.h.

References npstat::HistoND< Numeric, Axis >::axis(), npstat::HistoND< Numeric, Axis >::binContents(), npstat::Private::iHND_checkArgs(), and npstat::ArrayND< Numeric, StackLen, StackDim >::interpolate1().

    {
        const unsigned expDim = 1U;
        Private::iHND_checkArgs(histo, expDim, interpolationDegree);
        const double coords = histo.axis(0).fltBinNumber(x0, false);
        const ArrayND<Float>& bins(histo.binContents());
        switch (interpolationDegree)
        {
        case 1U:
            return bins.interpolate1(&coords, expDim);
        case 3U:
            return bins.interpolate3(&coords, expDim);
        default:
            return bins.closest(&coords, expDim);
        }        
    }
template<typename Float , class Axis >
Float npstat::interpolateHistoND ( const HistoND< Float, Axis > &  histo,
double  x0,
double  x1,
double  x2,
double  x3,
double  x4,
unsigned  interpolationDegree 
)

Definition at line 250 of file interpolateHistoND.h.

References lumiQTWidget::ax, npstat::HistoND< Numeric, Axis >::axes(), npstat::HistoND< Numeric, Axis >::binContents(), npstat::Private::iHND_checkArgs(), and npstat::ArrayND< Numeric, StackLen, StackDim >::interpolate1().

    {
        const unsigned expDim = 5U;
        Private::iHND_checkArgs(histo, expDim, interpolationDegree);
        const Axis* ax = &histo.axes()[0];
        double coords[expDim];
        coords[0] = ax[0].fltBinNumber(x0, false);
        coords[1] = ax[1].fltBinNumber(x1, false);
        coords[2] = ax[2].fltBinNumber(x2, false);
        coords[3] = ax[3].fltBinNumber(x3, false);
        coords[4] = ax[4].fltBinNumber(x4, false);
        const ArrayND<Float>& bins(histo.binContents());
        switch (interpolationDegree)
        {
        case 1U:
            return bins.interpolate1(coords, expDim);
        case 3U:
            return bins.interpolate3(coords, expDim);
        default:
            return bins.closest(coords, expDim);
        }        
    }
template<typename Float , class Axis >
Float npstat::interpolateHistoND ( const HistoND< Float, Axis > &  histo,
double  x0,
double  x1,
unsigned  interpolationDegree 
)

Definition at line 172 of file interpolateHistoND.h.

References lumiQTWidget::ax, npstat::HistoND< Numeric, Axis >::axes(), npstat::HistoND< Numeric, Axis >::binContents(), npstat::Private::iHND_checkArgs(), and npstat::ArrayND< Numeric, StackLen, StackDim >::interpolate1().

    {
        const unsigned expDim = 2U;
        Private::iHND_checkArgs(histo, expDim, interpolationDegree);
        const Axis* ax = &histo.axes()[0];
        double coords[expDim];
        coords[0] = ax[0].fltBinNumber(x0, false);
        coords[1] = ax[1].fltBinNumber(x1, false);
        const ArrayND<Float>& bins(histo.binContents());
        switch (interpolationDegree)
        {
        case 1U:
            return bins.interpolate1(coords, expDim);
        case 3U:
            return bins.interpolate3(coords, expDim);
        default:
            return bins.closest(coords, expDim);
        }        
    }
template<typename Float , class Axis >
Float npstat::interpolateHistoND ( const HistoND< Float, Axis > &  histo,
double  x0,
double  x1,
double  x2,
unsigned  interpolationDegree 
)

Definition at line 196 of file interpolateHistoND.h.

References lumiQTWidget::ax, npstat::HistoND< Numeric, Axis >::axes(), npstat::HistoND< Numeric, Axis >::binContents(), npstat::Private::iHND_checkArgs(), and npstat::ArrayND< Numeric, StackLen, StackDim >::interpolate1().

    {
        const unsigned expDim = 3U;
        Private::iHND_checkArgs(histo, expDim, interpolationDegree);
        const Axis* ax = &histo.axes()[0];
        double coords[expDim];
        coords[0] = ax[0].fltBinNumber(x0, false);
        coords[1] = ax[1].fltBinNumber(x1, false);
        coords[2] = ax[2].fltBinNumber(x2, false);
        const ArrayND<Float>& bins(histo.binContents());
        switch (interpolationDegree)
        {
        case 1U:
            return bins.interpolate1(coords, expDim);
        case 3U:
            return bins.interpolate3(coords, expDim);
        default:
            return bins.closest(coords, expDim);
        }        
    }
template<typename Float , class Axis >
Float npstat::interpolateHistoND ( const HistoND< Float, Axis > &  histo,
double  x0,
double  x1,
double  x2,
double  x3,
unsigned  interpolationDegree 
)

Definition at line 222 of file interpolateHistoND.h.

References lumiQTWidget::ax, npstat::HistoND< Numeric, Axis >::axes(), npstat::HistoND< Numeric, Axis >::binContents(), npstat::Private::iHND_checkArgs(), and npstat::ArrayND< Numeric, StackLen, StackDim >::interpolate1().

    {
        const unsigned expDim = 4U;
        Private::iHND_checkArgs(histo, expDim, interpolationDegree);
        const Axis* ax = &histo.axes()[0];
        double coords[expDim];
        coords[0] = ax[0].fltBinNumber(x0, false);
        coords[1] = ax[1].fltBinNumber(x1, false);
        coords[2] = ax[2].fltBinNumber(x2, false);
        coords[3] = ax[3].fltBinNumber(x3, false);
        const ArrayND<Float>& bins(histo.binContents());
        switch (interpolationDegree)
        {
        case 1U:
            return bins.interpolate1(coords, expDim);
        case 3U:
            return bins.interpolate3(coords, expDim);
        default:
            return bins.closest(coords, expDim);
        }        
    }
template<typename Float , class Axis >
Float npstat::interpolateHistoND ( const HistoND< Float, Axis > &  histo,
double  x0,
double  x1,
double  x2,
double  x3,
double  x4,
double  x5,
unsigned  interpolationDegree 
)

Definition at line 280 of file interpolateHistoND.h.

References lumiQTWidget::ax, npstat::HistoND< Numeric, Axis >::axes(), npstat::HistoND< Numeric, Axis >::binContents(), npstat::Private::iHND_checkArgs(), and npstat::ArrayND< Numeric, StackLen, StackDim >::interpolate1().

    {
        const unsigned expDim = 6U;
        Private::iHND_checkArgs(histo, expDim, interpolationDegree);
        const Axis* ax = &histo.axes()[0];
        double coords[expDim];
        coords[0] = ax[0].fltBinNumber(x0, false);
        coords[1] = ax[1].fltBinNumber(x1, false);
        coords[2] = ax[2].fltBinNumber(x2, false);
        coords[3] = ax[3].fltBinNumber(x3, false);
        coords[4] = ax[4].fltBinNumber(x4, false);
        coords[5] = ax[5].fltBinNumber(x5, false);
        const ArrayND<Float>& bins(histo.binContents());
        switch (interpolationDegree)
        {
        case 1U:
            return bins.interpolate1(coords, expDim);
        case 3U:
            return bins.interpolate3(coords, expDim);
        default:
            return bins.closest(coords, expDim);
        }        
    }
template<typename Float , class Axis >
Float npstat::interpolateHistoND ( const HistoND< Float, Axis > &  histo,
double  x0,
double  x1,
double  x2,
double  x3,
double  x4,
double  x5,
double  x6,
double  x7,
unsigned  interpolationDegree 
)

Definition at line 346 of file interpolateHistoND.h.

References lumiQTWidget::ax, npstat::HistoND< Numeric, Axis >::axes(), npstat::HistoND< Numeric, Axis >::binContents(), npstat::Private::iHND_checkArgs(), and npstat::ArrayND< Numeric, StackLen, StackDim >::interpolate1().

    {
        const unsigned expDim = 8U;
        Private::iHND_checkArgs(histo, expDim, interpolationDegree);
        const Axis* ax = &histo.axes()[0];
        double coords[expDim];
        coords[0] = ax[0].fltBinNumber(x0, false);
        coords[1] = ax[1].fltBinNumber(x1, false);
        coords[2] = ax[2].fltBinNumber(x2, false);
        coords[3] = ax[3].fltBinNumber(x3, false);
        coords[4] = ax[4].fltBinNumber(x4, false);
        coords[5] = ax[5].fltBinNumber(x5, false);
        coords[6] = ax[6].fltBinNumber(x6, false);
        coords[7] = ax[7].fltBinNumber(x7, false);
        const ArrayND<Float>& bins(histo.binContents());
        switch (interpolationDegree)
        {
        case 1U:
            return bins.interpolate1(coords, expDim);
        case 3U:
            return bins.interpolate3(coords, expDim);
        default:
            return bins.closest(coords, expDim);
        }        
    }
template<typename Float , class Axis >
Float npstat::interpolateHistoND ( const HistoND< Float, Axis > &  histo,
double  x0,
double  x1,
double  x2,
double  x3,
double  x4,
double  x5,
double  x6,
unsigned  interpolationDegree 
)

Definition at line 312 of file interpolateHistoND.h.

References lumiQTWidget::ax, npstat::HistoND< Numeric, Axis >::axes(), npstat::HistoND< Numeric, Axis >::binContents(), npstat::Private::iHND_checkArgs(), and npstat::ArrayND< Numeric, StackLen, StackDim >::interpolate1().

    {
        const unsigned expDim = 7U;
        Private::iHND_checkArgs(histo, expDim, interpolationDegree);
        const Axis* ax = &histo.axes()[0];
        double coords[expDim];
        coords[0] = ax[0].fltBinNumber(x0, false);
        coords[1] = ax[1].fltBinNumber(x1, false);
        coords[2] = ax[2].fltBinNumber(x2, false);
        coords[3] = ax[3].fltBinNumber(x3, false);
        coords[4] = ax[4].fltBinNumber(x4, false);
        coords[5] = ax[5].fltBinNumber(x5, false);
        coords[6] = ax[6].fltBinNumber(x6, false);
        const ArrayND<Float>& bins(histo.binContents());
        switch (interpolationDegree)
        {
        case 1U:
            return bins.interpolate1(coords, expDim);
        case 3U:
            return bins.interpolate3(coords, expDim);
        default:
            return bins.closest(coords, expDim);
        }        
    }
template<typename Float , class Axis >
Float npstat::interpolateHistoND ( const HistoND< Float, Axis > &  histo,
double  x0,
double  x1,
double  x2,
double  x3,
double  x4,
double  x5,
double  x6,
double  x7,
double  x8,
double  x9,
unsigned  interpolationDegree 
)

Definition at line 420 of file interpolateHistoND.h.

References lumiQTWidget::ax, npstat::HistoND< Numeric, Axis >::axes(), npstat::HistoND< Numeric, Axis >::binContents(), npstat::Private::iHND_checkArgs(), and npstat::ArrayND< Numeric, StackLen, StackDim >::interpolate1().

    {
        const unsigned expDim = 10U;
        Private::iHND_checkArgs(histo, expDim, interpolationDegree);
        const Axis* ax = &histo.axes()[0];
        double coords[expDim];
        coords[0] = ax[0].fltBinNumber(x0, false);
        coords[1] = ax[1].fltBinNumber(x1, false);
        coords[2] = ax[2].fltBinNumber(x2, false);
        coords[3] = ax[3].fltBinNumber(x3, false);
        coords[4] = ax[4].fltBinNumber(x4, false);
        coords[5] = ax[5].fltBinNumber(x5, false);
        coords[6] = ax[6].fltBinNumber(x6, false);
        coords[7] = ax[7].fltBinNumber(x7, false);
        coords[8] = ax[8].fltBinNumber(x8, false);
        coords[9] = ax[9].fltBinNumber(x9, false);
        const ArrayND<Float>& bins(histo.binContents());
        switch (interpolationDegree)
        {
        case 1U:
            return bins.interpolate1(coords, expDim);
        case 3U:
            return bins.interpolate3(coords, expDim);
        default:
            return bins.closest(coords, expDim);
        }        
    }
template<typename Float , class Axis >
Float npstat::interpolateHistoND ( const HistoND< Float, Axis > &  histo,
double  x0,
double  x1,
double  x2,
double  x3,
double  x4,
double  x5,
double  x6,
double  x7,
double  x8,
unsigned  interpolationDegree 
)

Definition at line 382 of file interpolateHistoND.h.

References lumiQTWidget::ax, npstat::HistoND< Numeric, Axis >::axes(), npstat::HistoND< Numeric, Axis >::binContents(), npstat::Private::iHND_checkArgs(), and npstat::ArrayND< Numeric, StackLen, StackDim >::interpolate1().

    {
        const unsigned expDim = 9U;
        Private::iHND_checkArgs(histo, expDim, interpolationDegree);
        const Axis* ax = &histo.axes()[0];
        double coords[expDim];
        coords[0] = ax[0].fltBinNumber(x0, false);
        coords[1] = ax[1].fltBinNumber(x1, false);
        coords[2] = ax[2].fltBinNumber(x2, false);
        coords[3] = ax[3].fltBinNumber(x3, false);
        coords[4] = ax[4].fltBinNumber(x4, false);
        coords[5] = ax[5].fltBinNumber(x5, false);
        coords[6] = ax[6].fltBinNumber(x6, false);
        coords[7] = ax[7].fltBinNumber(x7, false);
        coords[8] = ax[8].fltBinNumber(x8, false);
        const ArrayND<Float>& bins(histo.binContents());
        switch (interpolationDegree)
        {
        case 1U:
            return bins.interpolate1(coords, expDim);
        case 3U:
            return bins.interpolate3(coords, expDim);
        default:
            return bins.closest(coords, expDim);
        }        
    }
template<typename T >
unsigned npstat::interpolation_coefficients ( T *  buffer,
unsigned  bufLen,
const T &  f0,
const T &  f1 
)

Get the coefficients of the interpolating polynomial. The interpolated function values are provided at 0, 1, ... The return value of the function is the number of coefficients (i.e., the polynomial degree plus one). On exit, the coefficients are placed into the "buffer" array in the order of increasing monomial degree. The length of the provided buffer must be sufficient to hold all these coefficients.

Definition at line 83 of file interpolate.h.

    {
        if (bufLen <= 1U) throw npstat::NpstatInvalidArgument(
            "In npstat::interpolation_coefficients: "
            "insufficient length of the output buffer");
        buffer[0] = f0;
        buffer[1] = f1 - f0;
        return 2U;
    }
template<typename T >
unsigned npstat::interpolation_coefficients ( T *  buffer,
unsigned  bufLen,
const T &  f0,
const T &  f1,
const T &  f2,
const T &  f3 
)

Definition at line 108 of file interpolate.h.

References python::connectstrParser::f1, python::connectstrParser::f2, and python::connectstrParser::f3.

    {
        if (bufLen <= 3U) throw npstat::NpstatInvalidArgument(
            "In npstat::interpolation_coefficients: "
            "insufficient length of the output buffer");
        buffer[0] = f0;
        buffer[1] = static_cast<T>((11*(f1 - f0)+7*(f1 - f2)+2*(f3 - f2))/6.0);
        buffer[2] = static_cast<T>((2*(f0 - f1)+3*(f2 - f1)+(f2 - f3))/2.0);
        buffer[3] = static_cast<T>(((f3 - f0) + 3*(f1 - f2))/6.0);
        return 4U;
    }
template<typename T >
unsigned npstat::interpolation_coefficients ( T *  buffer,
unsigned  bufLen,
const T &  f0,
const T &  f1,
const T &  f2 
)

Definition at line 95 of file interpolate.h.

References python::connectstrParser::f1.

    {
        if (bufLen <= 2U) throw npstat::NpstatInvalidArgument(
            "In npstat::interpolation_coefficients: "
            "insufficient length of the output buffer");
        buffer[0] = f0;
        buffer[1] = static_cast<T>((f1 - f2 + 3*(f1 - f0))/2.0);
        buffer[2] = static_cast<T>(((f0 - f1) + (f2 - f1))/2.0);
        return 3U;
    }
template<class Iter >
bool npstat::isMonotonous ( Iter const  begin,
Iter const  end 
) [inline]

Check if the sequence of values is either non-increasing or non-decreasing

Definition at line 85 of file isMonotonous.h.

References isNonDecreasing(), and isNonIncreasing().

    {
        return isNonDecreasing(begin, end) || isNonIncreasing(begin, end);
    }
template<class Iter >
bool npstat::isNonDecreasing ( Iter  begin,
Iter const  end 
) [inline]

Check if the sequence of values is not decreasing

Definition at line 54 of file isMonotonous.h.

References begin, end, first, and ntuplemaker::status.

Referenced by isMonotonous().

    {
        if (begin == end)
            return false;
        Iter first(begin);
        bool status = ++begin != end;
        for (; begin != end && status; ++begin, ++first)
            if (*begin < *first)
                status = false;
        return status;
    }
template<class Iter >
bool npstat::isNonIncreasing ( Iter  begin,
Iter const  end 
) [inline]

Check if the sequence of values is not increasing

Definition at line 68 of file isMonotonous.h.

References begin, end, first, and ntuplemaker::status.

Referenced by isMonotonous().

    {
        if (begin == end)
            return false;
        Iter first(begin);
        bool status = ++begin != end;
        for (; begin != end && status; ++begin, ++first)
            if (*begin > *first)
                status = false;
        return status;
    }
template<class Iter >
bool npstat::isStrictlyDecreasing ( Iter  begin,
Iter const  end 
) [inline]

Check if the sequence of values is strictly decreasing

Definition at line 32 of file isMonotonous.h.

References begin, end, first, and ntuplemaker::status.

Referenced by isStrictlyMonotonous().

    {
        if (begin == end)
            return false;
        Iter first(begin);
        bool status = ++begin != end;
        for (; begin != end && status; ++begin, ++first)
            if (!(*begin < *first))
                status = false;
        return status;
    }
template<class Iter >
bool npstat::isStrictlyIncreasing ( Iter  begin,
Iter const  end 
) [inline]

Check if the sequence of values is strictly increasing

Definition at line 18 of file isMonotonous.h.

References begin, end, first, and ntuplemaker::status.

Referenced by isStrictlyMonotonous().

    {
        if (begin == end)
            return false;
        Iter first(begin);
        bool status = ++begin != end;
        for (; begin != end && status; ++begin, ++first)
            if (!(*first < *begin))
                status = false;
        return status;
    }
template<class Iter >
bool npstat::isStrictlyMonotonous ( Iter const  begin,
Iter const  end 
) [inline]

Check if the sequence of values is strictly increasing or decreasing

Definition at line 46 of file isMonotonous.h.

References isStrictlyDecreasing(), and isStrictlyIncreasing().

Referenced by npstat::Private::lind_invert1DSlice().

    {
        return isStrictlyIncreasing(begin, end) ||
               isStrictlyDecreasing(begin, end);
    }
bool npstat::isSubShape ( const ArrayShape &  sh1,
const ArrayShape &  sh2 
)

This function returns true if the number of elements is the same in both vectors and every element of the first vector does not exceed corresponding element of the second

Definition at line 178 of file ArrayShape.cc.

References i.

    {
        const unsigned len = sh1.size();
        if (len != sh2.size())
            return false;
        for (unsigned i=0; i<len; ++i)
            if (sh1[i] > sh2[i])
                return false;
        return true;
    }
template<typename T >
T* npstat::makeBuffer ( unsigned  sizeNeeded,
T *  stackBuffer,
unsigned  sizeofStackBuffer 
) [inline]

Function for allocating memory buffers if their size exceeds the size of the buffer available on the stack

Definition at line 22 of file allocators.h.

Referenced by npstat::ArrayND< Numeric, StackLen, StackDim >::addToProjection(), npstat::ArrayND< Numeric, StackLen, StackDim >::ArrayND(), npstat::ArrayND< Numeric, StackLen, StackDim >::buildFromShapePtr(), npstat::ArrayND< Numeric, StackLen, StackDim >::buildStrides(), npstat::ArrayND< Numeric, StackLen, StackDim >::contract(), npstat::ArrayND< Numeric, StackLen, StackDim >::dot(), npstat::ArrayND< Numeric, StackLen, StackDim >::functorFill(), npstat::ArrayND< Numeric, StackLen, StackDim >::processSubrange(), npstat::ArrayND< Numeric, StackLen, StackDim >::project(), npstat::ArrayND< Numeric, StackLen, StackDim >::restore(), npstat::ArrayND< Numeric, StackLen, StackDim >::subtractFromProjection(), and npstat::ArrayND< Numeric, StackLen, StackDim >::transpose().

    {
        if (sizeNeeded > sizeofStackBuffer || stackBuffer == 0)
            return new T[sizeNeeded];
        else
            return stackBuffer;
    }
ArrayShape npstat::makeShape ( unsigned  i0,
unsigned  i1,
unsigned  i2,
unsigned  i3,
unsigned  i4,
unsigned  i5,
unsigned  i6,
unsigned  i7,
unsigned  i8,
unsigned  i9 
)

Definition at line 123 of file ArrayShape.cc.

References alignCSCRings::s.

    {
        ArrayShape s;
        s.reserve(10);
        s.push_back(i0);
        s.push_back(i1);
        s.push_back(i2);
        s.push_back(i3);
        s.push_back(i4);
        s.push_back(i5);
        s.push_back(i6);
        s.push_back(i7);
        s.push_back(i8);
        s.push_back(i9);
        return s;
    }
ArrayShape npstat::makeShape ( unsigned  i0,
unsigned  i1,
unsigned  i2,
unsigned  i3,
unsigned  i4,
unsigned  i5,
unsigned  i6,
unsigned  i7 
)

Definition at line 89 of file ArrayShape.cc.

References alignCSCRings::s.

    {
        ArrayShape s;
        s.reserve(8);
        s.push_back(i0);
        s.push_back(i1);
        s.push_back(i2);
        s.push_back(i3);
        s.push_back(i4);
        s.push_back(i5);
        s.push_back(i6);
        s.push_back(i7);
        return s;
    }
ArrayShape npstat::makeShape ( const unsigned *  indices,
unsigned  nIndices 
)

Definition at line 142 of file ArrayShape.cc.

References i, and alignCSCRings::s.

    {
        ArrayShape s;
        if (nIndices)
        {
            assert(indices);
            s.reserve(nIndices);
            for (unsigned i=0; i<nIndices; ++i)
                s.push_back(indices[i]);
        }
        return s;
    }
ArrayShape npstat::makeShape ( unsigned  i0,
unsigned  i1,
unsigned  i2,
unsigned  i3,
unsigned  i4,
unsigned  i5 
)

Definition at line 60 of file ArrayShape.cc.

References alignCSCRings::s.

    {
        ArrayShape s;
        s.reserve(6);
        s.push_back(i0);
        s.push_back(i1);
        s.push_back(i2);
        s.push_back(i3);
        s.push_back(i4);
        s.push_back(i5);
        return s;
    }
ArrayShape npstat::makeShape ( unsigned  i0)

Definition at line 12 of file ArrayShape.cc.

    {
        return ArrayShape(1, i0);
    }
ArrayShape npstat::makeShape ( unsigned  i0,
unsigned  i1,
unsigned  i2,
unsigned  i3,
unsigned  i4,
unsigned  i5,
unsigned  i6 
)

Definition at line 74 of file ArrayShape.cc.

References alignCSCRings::s.

    {
        ArrayShape s;
        s.reserve(7);
        s.push_back(i0);
        s.push_back(i1);
        s.push_back(i2);
        s.push_back(i3);
        s.push_back(i4);
        s.push_back(i5);
        s.push_back(i6);
        return s;
    }
ArrayShape npstat::makeShape ( unsigned  i0,
unsigned  i1,
unsigned  i2,
unsigned  i3,
unsigned  i4,
unsigned  i5,
unsigned  i6,
unsigned  i7,
unsigned  i8 
)

Definition at line 105 of file ArrayShape.cc.

References alignCSCRings::s.

    {
        ArrayShape s;
        s.reserve(9);
        s.push_back(i0);
        s.push_back(i1);
        s.push_back(i2);
        s.push_back(i3);
        s.push_back(i4);
        s.push_back(i5);
        s.push_back(i6);
        s.push_back(i7);
        s.push_back(i8);
        return s;
    }
ArrayShape npstat::makeShape ( unsigned  i0,
unsigned  i1,
unsigned  i2,
unsigned  i3 
)

Definition at line 36 of file ArrayShape.cc.

References alignCSCRings::s.

    {
        ArrayShape s;
        s.reserve(4);
        s.push_back(i0);
        s.push_back(i1);
        s.push_back(i2);
        s.push_back(i3);
        return s;
    }
ArrayShape npstat::makeShape ( )

This convenience function will construct an array shape using an explicit list of indices

Definition at line 7 of file ArrayShape.cc.

    {
        return ArrayShape();
    }
ArrayShape npstat::makeShape ( unsigned  i0,
unsigned  i1,
unsigned  i2,
unsigned  i3,
unsigned  i4 
)

Definition at line 47 of file ArrayShape.cc.

References alignCSCRings::s.

    {
        ArrayShape s;
        s.reserve(5);
        s.push_back(i0);
        s.push_back(i1);
        s.push_back(i2);
        s.push_back(i3);
        s.push_back(i4);
        return s;
    }
ArrayShape npstat::makeShape ( unsigned  i0,
unsigned  i1 
)

Definition at line 17 of file ArrayShape.cc.

References alignCSCRings::s.

    {
        ArrayShape s;
        s.reserve(2);
        s.push_back(i0);
        s.push_back(i1);
        return s;
    }
ArrayShape npstat::makeShape ( unsigned  i0,
unsigned  i1,
unsigned  i2 
)

Definition at line 26 of file ArrayShape.cc.

References alignCSCRings::s.

    {
        ArrayShape s;
        s.reserve(3);
        s.push_back(i0);
        s.push_back(i1);
        s.push_back(i2);
        return s;
    }
dualCircularLoop npstat::me_macro_check_loop_prerequisites ( flatCircularScan  ,
flatCircularLoop   
)
npstat::me_macro_check_loop_prerequisites ( jointSubrangeScan  ,
commonSubrangeLoop   
)
template<typename Num1 , unsigned Len1, unsigned Dim1, typename Num2 , unsigned Len2, unsigned Dim2>
void npstat::rescanArray ( const ArrayND< Num1, Len1, Dim1 > &  from,
ArrayND< Num2, Len2, Dim2 > *  to,
unsigned  interpolationDegree = 0 
)

A utility for filling one array using values of another. The array shapes do not have to be the same but the ranks have to be. Roughly, the arrays are treated as values of histogram bins inside the unit box. The array "to" is filled either with the closest bin value of the array "from" or with an interpolated value (if "interpolationDegree" parameter is not 0).

interpolationDegree parameter must be one of 0, 1, or 3.

Definition at line 103 of file rescanArray.h.

References npstat::ArrayND< Numeric, StackLen, StackDim >::functorFill(), and npstat::ArrayND< Numeric, StackLen, StackDim >::rank().

    {
        assert(to);
        if (from.rank() != to->rank()) throw npstat::NpstatInvalidArgument(
            "In npstat::rescanArray: incompatible dimensionalities "
            "of input and output arrays");
        if (!(interpolationDegree == 0U ||
              interpolationDegree == 1U ||
              interpolationDegree == 3U)) throw npstat::NpstatInvalidArgument(
                  "In npstat::rescanArray: unsupported interpolation degree");
        to->functorFill(Private::ArrayMapper<Num1,Len1,Dim1,Num2,Len2,Dim2>(
                            from, *to, interpolationDegree));
    }
Generated for CMSSW Reference Manual by doxygen 1.7.3