npstat Namespace Reference

Namespaces
	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)
HistoAxis	convertToHistoAxis (const UniformAxis &gridAxis)
NUHistoAxis	convertToHistoAxis (const GridAxis &gridAxis, double xMin)
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)
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)
template<typename T1 , typename T2 >
void	transposeBuffer (T1 *dest, const T2 *source, const unsigned long dim)
template<typename T1 , typename T2 >
void	transposeBuffer (T1 *dest, const T2 *source, const unsigned long M, const unsigned long N)
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 100 of file allocators.h.

References i.

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::UniformAxis::isClose(), npstat::NUHistoAxis::isClose(), npstat::GridAxis::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 3626 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 create_public_lumi_plots::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 create_public_lumi_plots::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 create_public_lumi_plots::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 create_public_lumi_plots::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 3651 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 3637 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 create_public_lumi_plots::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,
		unsigned	interpolationDegree
	)

Definition at line 172 of file interpolateHistoND.h.

References create_public_lumi_plots::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 create_public_lumi_plots::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 create_public_lumi_plots::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,
		unsigned	interpolationDegree
	)

Definition at line 250 of file interpolateHistoND.h.

References create_public_lumi_plots::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,
		double	x2,
		double	x3,
		double	x4,
		double	x5,
		unsigned	interpolationDegree
	)

Definition at line 280 of file interpolateHistoND.h.

References create_public_lumi_plots::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,
		unsigned	interpolationDegree
	)

Definition at line 312 of file interpolateHistoND.h.

References create_public_lumi_plots::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,
		unsigned	interpolationDegree
	)

Definition at line 346 of file interpolateHistoND.h.

References create_public_lumi_plots::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,
		double	x7,
		double	x8,
		unsigned	interpolationDegree
	)

Definition at line 382 of file interpolateHistoND.h.

References create_public_lumi_plots::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 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 create_public_lumi_plots::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 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
	)

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

(

)

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

)

Definition at line 12 of file ArrayShape.cc.

    {
        return ArrayShape(1, i0);
    }

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;
    }

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	(	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,
		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,
		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
	)

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	(	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,
		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	(	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;
    }

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));
    }

template<typename T1 , typename T2 >

void npstat::transposeBuffer ( T1 *  dest, const T2 *  source, const unsigned long  dim  )

inline

Copy a buffer (with possible type conversion on the fly) transposing it in the process (treating as a square matrix)

Definition at line 57 of file allocators.h.

References alignCSCRings::dest, i, and j.

    {
        if (dim)
        {
            assert(dest);
            assert(source);
            for (unsigned long i=0; i<dim; ++i)
            {
                for (unsigned long j=0; j<dim; ++j)
                    dest[j*dim] = static_cast<T1>(*source++);
                ++dest;
            }
        }
    }

template<typename T1 , typename T2 >

void npstat::transposeBuffer ( T1 *  dest, const T2 *  source, const unsigned long  M, const unsigned long  N  )

inline

Copy a buffer (with possible type conversion on the fly) transposing it in the process (treating as an M x N matrix)

Definition at line 78 of file allocators.h.

References alignCSCRings::dest, i, j, and N.

    {
        if (M && N)
        {
            assert(dest);
            assert(source);
            for (unsigned long i=0; i<M; ++i)
            {
                for (unsigned long j=0; j<N; ++j)
                    dest[j*M] = static_cast<T1>(*source++);
                ++dest;
            }
        }
    }