lar::util::details::FitDataCollector< T, D > Class Template Reference

Class providing data collection for the simple polynomial fitters. More...

#include <SimpleFits.h>

Classes
struct	SumExtractor
struct	SumExtractor< Power, 0U >

Public Types
using	Data_t = T
	type of the data More...
using	Measurement_t = std::tuple< Data_t, Data_t >
	type of measurement without uncertainty More...
using	MeasurementAndUncertainty_t = std::tuple< Data_t, Data_t, Data_t >
	type of measurement with uncertainty More...

Public Member Functions
void	clear ()
	Clears all the statistics. More...
template<typename Stream >
void	Print (Stream &out) const
	Prints the statistics into a stream. More...
Add elements
bool	add (Data_t x, Data_t y, Data_t sy=Data_t(1.0))
	Adds one entry with specified x, y and uncertainty. More...
bool	add (Measurement_t value, Data_t sy=Data_t(1.0))
	Adds one entry with specified x, y and uncertainty. More...
bool	add (MeasurementAndUncertainty_t value)
	Adds one entry with specified x, y and uncertainty. More...
template<typename Iter >
void	add_without_uncertainty (Iter begin, Iter end)
	Adds measurements from a sequence, with no uncertainty. More...
template<typename Iter , typename Pred >
void	add_without_uncertainty (Iter begin, Iter end, Pred extractor)
	Adds measurements from a sequence with no uncertainty. More...
template<typename Cont , typename Pred >
void	add_without_uncertainty (Cont cont, Pred extractor)
	Adds all measurements from a container, with no uncertainty. More...
template<typename Cont >
void	add_without_uncertainty (Cont cont)
	Adds all measurements from a container, with no uncertainty. More...
template<typename VIter , typename UIter , typename VPred , typename UPred = identity>
unsigned int	add_with_uncertainty (VIter begin_value, VIter end_value, UIter begin_uncertainty, VPred value_extractor, UPred uncertainty_extractor=UPred())
	Adds measurements with uncertainties from a sequence. More...
template<typename Iter >
unsigned int	add_with_uncertainty (Iter begin, Iter end)
	Adds measurements with uncertainties from a sequence. More...
template<typename Cont >
unsigned int	add_with_uncertainty (Cont cont)
	Adds measurements with uncertainties from a container. More...

Static Public Member Functions
static Data_t	UncertaintyToWeight (Data_t s)
	Transforms an uncertainty into a weight ( ) More...
static Data_t	WeightToUncertainty (Data_t w)
	Transforms a weight back to an uncertainty ( ) More...

Static Public Attributes
static constexpr unsigned int	Degree = D
	Degree of the fit. More...
static constexpr unsigned int	NParams = Degree + 1

Protected Attributes
WeightTracker< Data_t >	s2
	accumulator for uncertainty More...
DataTracker< Degree *2, Data_t >	x
	accumulator for variable x^k More...
WeightTracker< Data_t >	y
	accumulator for y More...
DataTracker< 1, Data_t >	y2
	accumulator for y2 More...
DataTracker< Degree, Data_t >	xy
	accumulator for variable xy More...

Statistic retrieval
int	N () const
	Returns the number of entries added. More...
Data_t	AverageUncertainty () const
	Returns an average of the uncertainties. More...
Data_t	XN (unsigned int n) const
	Returns the weighted sum of x^n. More...
Data_t	XNY (unsigned int n) const
	Returns the weighted sum of x^n y. More...
template<unsigned int N>
Data_t	XN () const
	Returns the weighted sum of x^N. More...
template<unsigned int N>
Data_t	XNY () const
	Returns the weighted sum of x^N y. More...
Data_t	Y2 () const
	Returns the weighted sum of y^2. More...
template<typename V >
static constexpr V	sqr (V const &v)
	Returns the square of the specified value. More...

Detailed Description

template<typename T, unsigned int D>
class lar::util::details::FitDataCollector< T, D >

Class providing data collection for the simple polynomial fitters.

Definition at line 37 of file SimpleFits.h.

Member Typedef Documentation

template<typename T , unsigned int D>

using lar::util::details::FitDataCollector< T, D >::Data_t = T

type of the data

Definition at line 76 of file SimpleFits.h.

template<typename T , unsigned int D>

using lar::util::details::FitDataCollector< T, D >::Measurement_t = std::tuple<Data_t, Data_t>

type of measurement without uncertainty

Definition at line 79 of file SimpleFits.h.

template<typename T , unsigned int D>

using lar::util::details::FitDataCollector< T, D >::MeasurementAndUncertainty_t = std::tuple<Data_t, Data_t, Data_t>

type of measurement with uncertainty

Definition at line 82 of file SimpleFits.h.

Member Function Documentation

template<typename T , unsigned int D>

bool lar::util::details::FitDataCollector< T, D >::add	(	Data_t	x,
		Data_t	y,
		Data_t	sy = Data_t(1.0)
	)

Adds one entry with specified x, y and uncertainty.

Parameters

x	value of x
y	value of y
sy	value of uncertainty on y (1 by default)

Returns

whether the point was added

If the uncertainty is exactly 0, the entry is ignored and not added.

Definition at line 1446 of file SimpleFits.h.

{
  Data_t w = UncertaintyToWeight(sy);
  if (!std::isnormal(w)) return false;
  // the x section has a 1/s^2 weight; we track that weight separately
  s2.add(w);
  x.add(x_value, w);
  // we treat the y section as if it were a x section with a y/s^2 weight;
  // we track that weight separately
  Data_t yw = y_value * w;
  y.add(yw);
  y2.add(sqr(y_value), w); // used only for chi^2
  xy.add(x_value, yw);

  return true; // we did add the value
} // FitDataCollector<>::add()

template<typename T , unsigned int D>

bool lar::util::details::FitDataCollector< T, D >::add ( Measurement_t  value, Data_t  sy = Data_t(1.0)  )

inline

Adds one entry with specified x, y and uncertainty.

Parameters

value	the ( x ; y ) pair
sy	value of uncertainty on y (1 by default)

Returns

whether the point was added

If the uncertainty is exactly 0, the entry is ignored and not added.

Definition at line 108 of file SimpleFits.h.

          { return add(std::get<0>(value), std::get<1>(value), sy); }

template<typename T , unsigned int D>

bool lar::util::details::FitDataCollector< T, D >::add ( MeasurementAndUncertainty_t  value )

inline

Adds one entry with specified x, y and uncertainty.

Parameters

value

( x ; y ; sy ), sy being the uncertainty on y

Returns

whether the point was added

If the uncertainty is exactly 0, the entry is ignored and not added.

Definition at line 118 of file SimpleFits.h.

          {
            return
              add(std::get<0>(value), std::get<1>(value), std::get<2>(value));
          }

template<typename T , unsigned int D>

template<typename VIter , typename UIter , typename VPred , typename UPred >

unsigned int lar::util::details::FitDataCollector< T, D >::add_with_uncertainty	(	VIter	begin_value,
		VIter	end_value,
		UIter	begin_uncertainty,
		VPred	value_extractor,
		UPred	uncertainty_extractor = UPred()
	)

Adds measurements with uncertainties from a sequence.

Template Parameters

VIter	forward iterator to the elements to be added
UIter	forward iterator to the uncertainties
VPred	predicate to extract the measurement from iterator value
UPred	predicate to extract the uncertainty from iterator value

Parameters

begin_value	iterator to the first measurement to be added
end_value	iterator after the last measurement to be added
begin_uncertainty	iterator to the uncertainty of first measurement
value_extractor	predicate extracting the measurement to be inserted
uncertainty_extractor	predicate extracting the uncertainty

Returns

number of points added

Each element is added with the uncertainty pointed by the matching element in the list pointed by begin_weight: the measurement of *(begin_value) will have uncertainty *(begin_uncertainty), the next measurement *(begin_value + 1) will have uncertainty *(begin_uncertainty + 1), etc.

The predicates are required to react to a call like with:

Measurement_t VPred::operator() (typename VIter::value_type);
Data_t UPred::operator() (typename UIter::value_type);

Points with zero or infinite uncertainty are ignored and not added.

Definition at line 1477 of file SimpleFits.h.

  {
  unsigned int n = 0;
  while (begin_value != end_value) {
    if (add
      (value_extractor(*begin_value), uncertainty_extractor(*begin_uncertainty))
      )
      ++n;
    ++begin_value;
    ++begin_uncertainty;
  } // while
  return n;
} // FitDataCollector<>::add_with_uncertainty(VIter, VIter, UIter, VPred, UPred)

template<typename T , unsigned int D>

template<typename Iter >

unsigned int lar::util::details::FitDataCollector< T, D >::add_with_uncertainty	(	Iter	begin,
		Iter	end
	)

Adds measurements with uncertainties from a sequence.

Template Parameters

Iter	forward iterator to MeasurementAndUncertainty_t to be added

Parameters

begin	iterator pointing to the first measurement to be added
end	iterator pointing after the last measurement to be added

Returns

number of points added

The value pointed by the iterator must be a MeasurementAndUncertainty_t or something with elements convertible to its own (Data_t triplet). For more complicate structures, use the version with two predicates (using the uncertainty iterator the same as the measurement iterator).

Points with zero or infinite uncertainty are ignored and not added.

Definition at line 1499 of file SimpleFits.h.

{
  unsigned int old_n = N();
  std::for_each(begin, end, [this](auto p) { this->add(p); });
  return N() - old_n;
} // FitDataCollector<>::add_with_uncertainty(Iter, Iter)

template<typename T , unsigned int D>

template<typename Cont >

unsigned int lar::util::details::FitDataCollector< T, D >::add_with_uncertainty ( Cont  cont )

inline

Adds measurements with uncertainties from a container.

Template Parameters

Cont	type of container of MeasurementAndUncertainty_t elements

Parameters

cont	container of MeasurementAndUncertainty_t to be added

Returns

number of points added

The values in the container must be tuples with each element convertible to Data_t.

Points with zero or infinite uncertainty are ignored and not added.

Definition at line 254 of file SimpleFits.h.

          { return add_with_uncertainty(std::begin(cont), std::end(cont)); }

template<typename T , unsigned int D>

template<typename Iter >

void lar::util::details::FitDataCollector< T, D >::add_without_uncertainty ( Iter  begin, Iter  end  )

inline

Adds measurements from a sequence, with no uncertainty.

Template Parameters

Iter	forward iterator to the pairs to be added

Parameters

begin	iterator pointing to the first element to be added
end	iterator pointing after the last element to be added

The value pointed by the iterator must be a tuple with types compatible with Measurement_t.

Definition at line 135 of file SimpleFits.h.

          {  add_without_uncertainty(begin, end, identity()); }

template<typename T , unsigned int D>

template<typename Iter , typename Pred >

void lar::util::details::FitDataCollector< T, D >::add_without_uncertainty	(	Iter	begin,
		Iter	end,
		Pred	extractor
	)

Adds measurements from a sequence with no uncertainty.

Template Parameters

Iter	forward iterator to the elements to be added
Pred	a predicate to extract the element from iterator value

Parameters

begin	iterator pointing to the first element to be added
end	iterator pointing after the last element to be added
extractor	the predicate extracting the value to be inserted

The predicate is required to react to a call like with:

Measurement_t Pred::operator() (typename Iter::value_type);

Definition at line 1467 of file SimpleFits.h.

{
  std::for_each
    (begin, end, [this, extractor](auto item) { this->add(extractor(item)); });
} // FitDataCollector<>::add_without_uncertainty(Iter, Pred)

template<typename T , unsigned int D>

template<typename Cont , typename Pred >

void lar::util::details::FitDataCollector< T, D >::add_without_uncertainty ( Cont  cont, Pred  extractor  )

inline

Adds all measurements from a container, with no uncertainty.

Template Parameters

Cont	type of container of the elements to be added
Pred	a predicate to extract the element from iterator value

Parameters

cont	container of the elements to be added
extractor	the predicate extracting the value to be inserted

The predicate is required to react to a call like with:

Measurement_t Pred::operator() (typename Cont::value_type);

The container must support the range-based for loop syntax, that is is must have std::begin<Cont>() and std::end<Cont>() defined.

Definition at line 169 of file SimpleFits.h.

          { add_without_uncertainty(std::begin(cont), std::end(cont), extractor); }

template<typename T , unsigned int D>

template<typename Cont >

void lar::util::details::FitDataCollector< T, D >::add_without_uncertainty ( Cont  cont )

inline

Adds all measurements from a container, with no uncertainty.

Template Parameters

Cont	type of container of the elements to be added

Parameters

cont	container of the elements to be added

The container must support the range-based for loop syntax, that is is must have std::begin<Cont>() and std::end<Cont>() defined. The value in the container must be convertible to the Measurement_t type.

Definition at line 183 of file SimpleFits.h.

          { add_without_uncertainty(std::begin(cont), std::end(cont)); }

template<typename T , unsigned int D>

Data_t lar::util::details::FitDataCollector< T, D >::AverageUncertainty ( ) const

inline

Returns an average of the uncertainties.

Returns

the uncertainty average

Exceptions

std::range_error

if no entry was added

The average is the square root of the harmonic average of the variances (that is, the errors squared):

Definition at line 277 of file SimpleFits.h.

          { return WeightToUncertainty(s2.AverageWeight()); }

template<typename T , unsigned int D>

void lar::util::details::FitDataCollector< T, D >::clear ( )

inline

Clears all the statistics.

Definition at line 1509 of file SimpleFits.h.

                                                        {
  s2.clear();
  x.clear();
  y.clear();
  y2.clear();
  xy.clear();
} // FitDataCollector<>::clear()

template<typename T , unsigned int D>

int lar::util::details::FitDataCollector< T, D >::N ( void  ) const

inline

Returns the number of entries added.

Definition at line 266 of file SimpleFits.h.

{ return s2.N(); }

template<typename T , unsigned int D>

template<typename Stream >

void lar::util::details::FitDataCollector< T, D >::Print

(

Stream &

out

)

const

Prints the statistics into a stream.

Definition at line 1519 of file SimpleFits.h.

                                                                  {

  out << "Sums  1/s^2=" << s2.Weights()
    << "\n      x/s^2=" << x.template SumN<1>();
  for (unsigned int degree = 2; degree <= x.Power; ++degree)
    out << "\n    x^" << degree << "/s^2=" << x.Sum(degree);
  out
    << "\n      y/s^2=" << y.Weights()
    << "\n    y^2/s^2=" << y2.Sum();
  if (xy.Power >= 1)
    out << "\n     xy/s^2=" << xy.template SumN<1>();
  for (unsigned int degree = 2; degree <= xy.Power; ++degree)
    out << "\n   x^" << degree << "y/s^2=" << xy.Sum(degree);
  out << std::endl;
} // FitDataCollector<>::Print()

template<typename T , unsigned int D>

template<typename V >

static constexpr V lar::util::details::FitDataCollector< T, D >::sqr ( V const &  v )

inlinestatic

Returns the square of the specified value.

Definition at line 283 of file SimpleFits.h.

{ return v*v; }

template<typename T , unsigned int D>

static Data_t lar::util::details::FitDataCollector< T, D >::UncertaintyToWeight ( Data_t  s )

inlinestatic

Transforms an uncertainty into a weight ( )

Definition at line 317 of file SimpleFits.h.

          { return Data_t(1.)/sqr(s); }

template<typename T , unsigned int D>

static Data_t lar::util::details::FitDataCollector< T, D >::WeightToUncertainty ( Data_t  w )

inlinestatic

Transforms a weight back to an uncertainty ( )

Definition at line 321 of file SimpleFits.h.

          { return Data_t(1.)/std::sqrt(w); }

template<typename T , unsigned int D>

Data_t lar::util::details::FitDataCollector< T, D >::XN ( unsigned int  n ) const

inline

Returns the weighted sum of x^n.

Definition at line 287 of file SimpleFits.h.

          { return (n == 0)? s2.Weights(): x.Sum(n); }

template<typename T , unsigned int D>

template<unsigned int N>

Data_t lar::util::details::FitDataCollector< T, D >::XN ( ) const

inline

Returns the weighted sum of x^N.

Definition at line 297 of file SimpleFits.h.

          { return SumExtractor<decltype(x)::Power, N>::Sum(s2, x); }

template<typename T , unsigned int D>

Data_t lar::util::details::FitDataCollector< T, D >::XNY ( unsigned int  n ) const

inline

Returns the weighted sum of x^n y.

Definition at line 291 of file SimpleFits.h.

          { return (n == 0)? y.Weights(): xy.Sum(n); }

template<typename T , unsigned int D>

template<unsigned int N>

Data_t lar::util::details::FitDataCollector< T, D >::XNY ( ) const

inline

Returns the weighted sum of x^N y.

Definition at line 302 of file SimpleFits.h.

          { return SumExtractor<decltype(xy)::Power, N>::Sum(y, xy); }

template<typename T , unsigned int D>

Data_t lar::util::details::FitDataCollector< T, D >::Y2 ( ) const

inline

Returns the weighted sum of y^2.

Definition at line 307 of file SimpleFits.h.

{ return y2.template SumN<1>(); }

Member Data Documentation

template<typename T , unsigned int D>

constexpr unsigned int lar::util::details::FitDataCollector< T, D >::Degree = D

static

Degree of the fit.

Definition at line 73 of file SimpleFits.h.

template<typename T , unsigned int D>

constexpr unsigned int lar::util::details::FitDataCollector< T, D >::NParams = Degree + 1

static

Definition at line 74 of file SimpleFits.h.

template<typename T , unsigned int D>

WeightTracker<Data_t> lar::util::details::FitDataCollector< T, D >::s2

protected

accumulator for uncertainty

Definition at line 327 of file SimpleFits.h.

template<typename T , unsigned int D>

DataTracker<Degree*2, Data_t> lar::util::details::FitDataCollector< T, D >::x

protected

accumulator for variable x^k

Definition at line 328 of file SimpleFits.h.

template<typename T , unsigned int D>

DataTracker<Degree, Data_t> lar::util::details::FitDataCollector< T, D >::xy

protected

accumulator for variable xy

Definition at line 331 of file SimpleFits.h.

template<typename T , unsigned int D>

WeightTracker<Data_t> lar::util::details::FitDataCollector< T, D >::y

protected

accumulator for y

Definition at line 329 of file SimpleFits.h.

template<typename T , unsigned int D>

DataTracker<1, Data_t> lar::util::details::FitDataCollector< T, D >::y2

protected

accumulator for y2

Definition at line 330 of file SimpleFits.h.

---

The documentation for this class was generated from the following file:

• lardata/lardata/Utilities/SimpleFits.h