GaussianSumUtilities1D Class Reference

#include <GaussianSumUtilities1D.h>

Classes
struct	FinderState

Public Member Functions
double	cdf (const double &) const
	value of the c.d.f. More...
const std::vector< SingleGaussianState1D > &	components () const
	components More...
double	d1LnPdf (const double &) const
	first derivative of ln(pdf) More...
double	d1Pdf (const double &) const
	first derivative of the p.d.f. More...
double	d2LnPdf (const double &) const
	second derivative of ln(pdf) More...
double	d2Pdf (const double &) const
	second derivative of the p.d.f. More...
double	d3Pdf (const double &) const
	third derivative of the p.d.f. More...
	GaussianSumUtilities1D (const MultiGaussianState1D &state)
double	lnPdf (const double &) const
	ln(pdf) More...
double	mean () const
	combined mean More...
double	mean (unsigned int i) const
	mean value of a component More...
const SingleGaussianState1D &	mode () const
bool	modeIsValid () const
	mode status More...
double	pdf (double) const
	value of the p.d.f. More...
double	pdf (unsigned int i, double x) const
	pdf of a single component at x More...
double	quantile (const double) const
	Quantile (i.e. x for a given value of the c.d.f.) More...
unsigned int	size () const
	number of components More...
double	standardDeviation (unsigned int i) const
	standard deviation of a component More...
double	variance () const
	combined covariance More...
double	variance (unsigned int i) const
	variance of a component More...
double	weight () const
	combined weight More...
double	weight (unsigned int i) const
	weight of a component More...
	~GaussianSumUtilities1D ()

Private Types
enum	ModeStatus { Valid, NotValid, NotComputed }

Private Member Functions
double	combinedMean () const
	Mean value of combined state. More...
void	computeMode () const
	calculation of mode More...
double	d1LnPdf (double, const std::vector< double > &) const
	first derivative of ln(pdf) using the pdf components at the evaluation point More...
double	d1Pdf (double, const std::vector< double > &) const
	first derivative of the p.d.f. using the pdf components at the evaluation point More...
double	d2LnPdf (double, const std::vector< double > &) const
	second derivative of ln(pdf) using the pdf components at the evaluation point More...
double	d2Pdf (double, const std::vector< double > &) const
	second derivative of the p.d.f. using the pdf components at the evaluation point More...
double	d3Pdf (double, const std::vector< double > &) const
	third derivative of the p.d.f. using the pdf components at the evaluation point More...
bool	findMode (double &mode, double &pdfAtMode, const double &xStart, const double &scale) const
double	localVariance (double x) const
std::vector< double >	pdfComponents (const double &) const
	pdf components More...
void	pdfComponents (double, std::vector< double > &) const
	pdf components More...
void	update (FinderState &state, double x) const

Static Private Member Functions
static double	gauss (double, double, double)
	Value of gaussian distribution. More...
static double	gaussInt (double, double, double)
	Integrated value of gaussian distribution. More...
static double	lnPdf (double, const std::vector< double > &)
	ln(pdf) using the pdf components at the evaluation point More...
static double	pdf (double, const std::vector< double > &)
	value of the p.d.f. using the pdf components at the evaluation point More...

Private Attributes
SingleGaussianState1D	theMode
ModeStatus	theModeStatus
const MultiGaussianState1D &	theState

Detailed Description

Utility class for the analysis of one-dimensional Gaussian mixtures. The input state is assumed to exist for the lifetime of this object.

Definition at line 16 of file GaussianSumUtilities1D.h.

Member Enumeration Documentation

ModeStatus

enum GaussianSumUtilities1D::ModeStatus

private

Enumerator
Valid
NotValid
NotComputed

Definition at line 18 of file GaussianSumUtilities1D.h.

{ Valid, NotValid, NotComputed };

Constructor & Destructor Documentation

GaussianSumUtilities1D()

GaussianSumUtilities1D::GaussianSumUtilities1D ( const MultiGaussianState1D &  state )

inline

Definition at line 21 of file GaussianSumUtilities1D.h.

      : theState(state),
        //     theStates(state.components()),
        theModeStatus(NotComputed) {}

~GaussianSumUtilities1D()

GaussianSumUtilities1D::~GaussianSumUtilities1D ( )

inline

Definition at line 25 of file GaussianSumUtilities1D.h.

{}

Member Function Documentation

cdf()

double GaussianSumUtilities1D::cdf

(

const double &

x

)

const

value of the c.d.f.

Definition at line 268 of file GaussianSumUtilities1D.cc.

                                                        {
  double result(0.);
  size_t s = size();
  for (unsigned int i = 0; i < s; i++)
    result += weight(i) * gaussInt(x, mean(i), standardDeviation(i));
  return result;
}

References gaussInt(), mps_fire::i, mean(), mps_fire::result, alignCSCRings::s, size(), standardDeviation(), weight(), and x.

combinedMean()

double GaussianSumUtilities1D::combinedMean ( ) const

private

Mean value of combined state.

Definition at line 399 of file GaussianSumUtilities1D.cc.

                                                  {
  double s0(0.);
  double s1(0.);
  int s = size();
  SingleGaussianState1D const* __restrict__ sgv = &components().front();
  for (int i = 0; i < s; i++)
    s0 += sgv[i].weight();
  for (int i = 0; i < s; i++)
    s1 += sgv[i].weight() * sgv[i].mean();
  return s1 / s0;
}

References components(), mps_fire::i, alignCSCRings::s, size(), and weight().

components()

const std::vector<SingleGaussianState1D>& GaussianSumUtilities1D::components ( ) const

inline

components

Definition at line 30 of file GaussianSumUtilities1D.h.

{ return theState.components(); }

References MultiGaussianState1D::components(), and theState.

Referenced by combinedMean(), computeMode(), mean(), pdfComponents(), size(), standardDeviation(), variance(), and weight().

computeMode()

void GaussianSumUtilities1D::computeMode ( ) const

private

calculation of mode

Definition at line 91 of file GaussianSumUtilities1D.cc.

                                               {
  //   TimerStack tstack;
  //   tstack.benchmark("GSU1D::benchmark",100000);
  //   FastTimerStackPush(tstack,"GaussianSumUtilities1D::computeMode");
  theModeStatus = NotValid;
  //
  // check for "degenerate" states (identical values with vanishing error)
  //
  if (theState.variance() < 1.e-14) {
    theMode = SingleGaussianState1D(theState.mean(), theState.variance(), theState.weight());
    theModeStatus = Valid;
    return;
  }
  //
  // Use means of individual components as start values.
  // Sort by value of pdf.
  //
  typedef std::multimap<double, int, std::greater<double> > StartMap;
  StartMap xStart;
  for (unsigned int i = 0; i < size(); i++) {
    xStart.insert(std::make_pair(pdf(mean(i)), i));
  }
  //
  // Now try with each start value
  //
  int iRes(-1);                                 // index of start component for current estimate
  double xRes(mean((*xStart.begin()).second));  // current estimate of mode
  double yRes(-1.);                             // pdf at current estimate of mode
  //   std::pair<double,double> result(-1.,mean((*xStart.begin()).second));
  for (StartMap::const_iterator i = xStart.begin(); i != xStart.end(); i++) {
    //
    // Convergence radius for a single Gaussian = 1 sigma: don't try
    // start values within 1 sigma of the current solution
    //
    if (theModeStatus == Valid && fabs(mean((*i).second) - mean(iRes)) / standardDeviation(iRes) < 1.)
      continue;
    //
    // If a solution exists: drop as soon as the pdf at
    // start value drops to < 75% of maximum (try to avoid
    // unnecessary searches for the mode)
    //
    if (theModeStatus == Valid && (*i).first / (*xStart.begin()).first < 0.75)
      break;
    //
    // Try to find mode
    //
    double x;
    double y;
    bool valid = findMode(x, y, mean((*i).second), standardDeviation((*i).second));
    //
    // consider only successful searches
    //
    if (valid) {  //...
      //
      // update result only for significant changes in pdf(solution)
      //
      if (yRes < 0. || (y - yRes) / (y + yRes) > 1.e-10) {
        iRes = (*i).second;     // store index
        theModeStatus = Valid;  // update status
        xRes = x;               // current solution
        yRes = y;               // and its pdf value
                                //       result = std::make_pair(y,x);     // store solution and pdf(solution)
      }
    }  //...
  }
  //
  // check (existance of) solution
  //
  if (theModeStatus == Valid) {
    //
    // Construct single Gaussian state with
    //  mean = mode
    //  variance = local variance at mode
    //  weight such that the pdf's of the mixture and the
    //    single state are equal at the mode
    //
    double mode = xRes;
    double varMode = localVariance(mode);
    double wgtMode = pdf(mode) * sqrt(2 * M_PI * varMode);
    theMode = SingleGaussianState1D(mode, varMode, wgtMode);
  } else {
    //
    // mode finding failed: set solution to highest component
    //  (alternative would be global mean / variance ..?)
    //
    //two many log warnings to actually be useful - comment out
    //edm::LogWarning("GaussianSumUtilities") << "1D mode calculation failed";
    //     double x = mean();
    //     double y = pdf(x);
    //     result = std::make_pair(y,x);
    //     theMode = SingleGaussianState1D(mean(),variance(),weight());
    //
    // look for component with highest value at mean
    //
    int icMax(0);
    double ySqMax(0.);
    int s = size();
    for (int ic = 0; ic < s; ++ic) {
      double w = weight(ic);
      double ySq = w * w / variance(ic);
      if (ySq > ySqMax) {
        icMax = ic;
        ySqMax = ySq;
      }
    }
    theMode = SingleGaussianState1D(components()[icMax]);
  }
}

References components(), MillePedeFileConverter_cfg::e, findMode(), dqmdumpme::first, mps_fire::i, localVariance(), M_PI, MultiGaussianState1D::mean(), mean(), mode(), NotValid, pdf(), alignCSCRings::s, edm::second(), size(), mathSSE::sqrt(), standardDeviation(), theMode, theModeStatus, theState, Valid, validateGeometry_cfg::valid, MultiGaussianState1D::variance(), variance(), w, MultiGaussianState1D::weight(), weight(), x, and y.

Referenced by mode(), and modeIsValid().

d1LnPdf() [1/2]

double GaussianSumUtilities1D::d1LnPdf

(

const double &

x

)

const

first derivative of ln(pdf)

Definition at line 284 of file GaussianSumUtilities1D.cc.

{ return d1LnPdf(x, pdfComponents(x)); }

References pdfComponents(), and x.

Referenced by d2LnPdf().

d1LnPdf() [2/2]

double GaussianSumUtilities1D::d1LnPdf ( double  x, const std::vector< double > &  pdfs  ) const

private

first derivative of ln(pdf) using the pdf components at the evaluation point

Definition at line 365 of file GaussianSumUtilities1D.cc.

                                                                                    {
  double f = pdf(x, pdfs);
  double result(d1Pdf(x, pdfs));
  if (f > std::numeric_limits<double>::min())
    result /= f;
  else
    result = 0.;
  return result;
}

References d1Pdf(), f, min(), pdf(), mps_fire::result, and x.

d1Pdf() [1/2]

double GaussianSumUtilities1D::d1Pdf

(

const double &

x

)

const

first derivative of the p.d.f.

Definition at line 276 of file GaussianSumUtilities1D.cc.

{ return d1Pdf(x, pdfComponents(x)); }

References pdfComponents(), and x.

Referenced by d1LnPdf(), and update().

d1Pdf() [2/2]

double GaussianSumUtilities1D::d1Pdf ( double  x, const std::vector< double > &  pdfs  ) const

private

first derivative of the p.d.f. using the pdf components at the evaluation point

Definition at line 327 of file GaussianSumUtilities1D.cc.

                                                                                  {
  double result(0.);
  size_t s = size();
  for (unsigned int i = 0; i < s; i++) {
    double dx = (x - mean(i)) / standardDeviation(i);
    result += -pdfs[i] * dx / standardDeviation(i);
  }
  return result;
}

References PVValHelper::dx, mps_fire::i, mean(), mps_fire::result, alignCSCRings::s, size(), standardDeviation(), and x.

d2LnPdf() [1/2]

double GaussianSumUtilities1D::d2LnPdf

(

const double &

x

)

const

second derivative of ln(pdf)

Definition at line 286 of file GaussianSumUtilities1D.cc.

{ return d2LnPdf(x, pdfComponents(x)); }

References pdfComponents(), and x.

d2LnPdf() [2/2]

double GaussianSumUtilities1D::d2LnPdf ( double  x, const std::vector< double > &  pdfs  ) const

private

second derivative of ln(pdf) using the pdf components at the evaluation point

Definition at line 375 of file GaussianSumUtilities1D.cc.

                                                                                    {
  double f = pdf(x, pdfs);
  double df = d1LnPdf(x, pdfs);
  double result(-df * df);
  if (f > std::numeric_limits<double>::min())
    result += d2Pdf(x, pdfs) / f;
  return result;
}

References d1LnPdf(), d2Pdf(), f, min(), pdf(), mps_fire::result, and x.

d2Pdf() [1/2]

double GaussianSumUtilities1D::d2Pdf

(

const double &

x

)

const

second derivative of the p.d.f.

Definition at line 278 of file GaussianSumUtilities1D.cc.

{ return d2Pdf(x, pdfComponents(x)); }

References pdfComponents(), and x.

Referenced by d2LnPdf(), localVariance(), and update().

d2Pdf() [2/2]

double GaussianSumUtilities1D::d2Pdf ( double  x, const std::vector< double > &  pdfs  ) const

private

second derivative of the p.d.f. using the pdf components at the evaluation point

Definition at line 337 of file GaussianSumUtilities1D.cc.

                                                                                  {
  double result(0.);
  size_t s = size();
  for (unsigned int i = 0; i < s; i++) {
    double dx = (x - mean(i)) / standardDeviation(i);
    result += pdfs[i] / standardDeviation(i) / standardDeviation(i) * (dx * dx - 1);
  }
  return result;
}

References PVValHelper::dx, mps_fire::i, mean(), mps_fire::result, alignCSCRings::s, size(), standardDeviation(), and x.

d3Pdf() [1/2]

double GaussianSumUtilities1D::d3Pdf

(

const double &

x

)

const

third derivative of the p.d.f.

Definition at line 280 of file GaussianSumUtilities1D.cc.

{ return d3Pdf(x, pdfComponents(x)); }

References pdfComponents(), and x.

d3Pdf() [2/2]

double GaussianSumUtilities1D::d3Pdf ( double  x, const std::vector< double > &  pdfs  ) const

private

third derivative of the p.d.f. using the pdf components at the evaluation point

Definition at line 347 of file GaussianSumUtilities1D.cc.

                                                                                  {
  double result(0.);
  size_t s = size();
  for (unsigned int i = 0; i < s; i++) {
    double dx = (x - mean(i)) / standardDeviation(i);
    result += pdfs[i] / standardDeviation(i) / standardDeviation(i) / standardDeviation(i) * (-dx * dx + 3) * dx;
  }
  return result;
}

References PVValHelper::dx, mps_fire::i, mean(), mps_fire::result, alignCSCRings::s, size(), standardDeviation(), and x.

findMode()

bool GaussianSumUtilities1D::findMode ( double &  mode, double &  pdfAtMode, const double &  xStart, const double &  scale  ) const

private

Finds mode. Input: start value and typical scale. Output: mode and pdf(mode). Return value is true on success.

Definition at line 200 of file GaussianSumUtilities1D.cc.

                                                                                                                   {
  //
  // try with Newton on (lnPdf)'(x)
  //
  double x1(0.);
  double y1(0.);
  FinderState state(size());
  update(state, xStart);
 
  double xmin(xStart - 1. * scale);
  double xmax(xStart + 1. * scale);
  //
  // preset result
  //
  bool result(false);
  xMode = state.x;
  yMode = state.y;
  //
  // Iterate
  //
  int nLoop(0);
  while (nLoop++ < 20) {
    if (nLoop > 1 && state.yd2 < 0. &&
        (fabs(state.yd * scale) < 1.e-10 || fabs(state.y - y1) / (state.y + y1) < 1.e-14)) {
      result = true;
      break;
    }
    if (fabs(state.yd2) < std::numeric_limits<float>::min())
      state.yd2 = state.yd2 > 0. ? std::numeric_limits<float>::min() : -std::numeric_limits<float>::min();
    double dx = -state.yd / state.yd2;
    x1 = state.x;
    y1 = state.y;
    double x2 = x1 + dx;
    if (state.yd2 > 0. && (x2 < xmin || x2 > xmax))
      return false;
    update(state, x2);
  }
  //
  // result
  //
  if (result) {
    xMode = state.x;
    yMode = state.y;
  }
  return result;
}

References PVValHelper::dx, min(), mps_fire::result, Scenarios_cff::scale, size(), update(), GaussianSumUtilities1D::FinderState::x, testProducerWithPsetDescEmpty_cfi::x1, testProducerWithPsetDescEmpty_cfi::x2, TrackerOfflineValidation_Dqm_cff::xmax, TrackerOfflineValidation_Dqm_cff::xmin, GaussianSumUtilities1D::FinderState::y, testProducerWithPsetDescEmpty_cfi::y1, GaussianSumUtilities1D::FinderState::yd, and GaussianSumUtilities1D::FinderState::yd2.

Referenced by computeMode().

gauss()

double GaussianSumUtilities1D::gauss ( double  x, double  mean, double  sigma  )

staticprivate

Value of gaussian distribution.

Definition at line 384 of file GaussianSumUtilities1D.cc.

                                                                        {
  //   const double fNorm(1./sqrt(2*M_PI));
  //   double result(0.);
 
  //   double d((x-mean)/sigma);
  //   if ( fabs(d)<20. )  result = exp(-d*d/2.);
  //   result *= fNorm/sigma;
  //   return result;
  return ROOT::Math::gaussian_pdf(x, sigma, mean);
}

References mean(), and x.

Referenced by pdf(), and pdfComponents().

gaussInt()

double GaussianSumUtilities1D::gaussInt ( double  x, double  mean, double  sigma  )

staticprivate

Integrated value of gaussian distribution.

Definition at line 395 of file GaussianSumUtilities1D.cc.

                                                                           {
  return ROOT::Math::normal_cdf(x, sigma, mean);
}

References mean(), and x.

Referenced by cdf().

lnPdf() [1/2]

double GaussianSumUtilities1D::lnPdf

(

const double &

x

)

const

ln(pdf)

Definition at line 282 of file GaussianSumUtilities1D.cc.

{ return lnPdf(x, pdfComponents(x)); }

References pdfComponents(), and x.

lnPdf() [2/2]

double GaussianSumUtilities1D::lnPdf ( double  x, const std::vector< double > &  pdfs  )

staticprivate

ln(pdf) using the pdf components at the evaluation point

Definition at line 357 of file GaussianSumUtilities1D.cc.

                                                                            {
  double f(pdf(x, pdfs));
  double result(-std::numeric_limits<float>::max());
  if (f > std::numeric_limits<double>::min())
    result = log(f);
  return result;
}

References f, dqm-mbProfile::log, SiStripPI::max, min(), pdf(), mps_fire::result, and x.

localVariance()

double GaussianSumUtilities1D::localVariance ( double  x ) const

private

Local variance from Hessian matrix. Only valid if x corresponds to a (local) maximum!

Definition at line 411 of file GaussianSumUtilities1D.cc.

                                                           {
  std::vector<double> pdfs;
  pdfComponents(x, pdfs);
  double result = -pdf(x, pdfs) / d2Pdf(x, pdfs);
  // FIXME: wrong curvature seems to be non-existant but should add a proper recovery
  if (result < 0.)
    edm::LogWarning("GaussianSumUtilities") << "1D variance at mode < 0";
  return result;
}

References d2Pdf(), pdf(), pdfComponents(), mps_fire::result, and x.

Referenced by computeMode().

mean() [1/2]

double GaussianSumUtilities1D::mean ( ) const

inline

combined mean

Definition at line 71 of file GaussianSumUtilities1D.h.

{ return theState.mean(); }

References MultiGaussianState1D::mean(), and theState.

Referenced by cdf(), computeMode(), d1Pdf(), d2Pdf(), d3Pdf(), gauss(), gaussInt(), pdf(), and pdfComponents().

mean() [2/2]

double GaussianSumUtilities1D::mean ( unsigned int  i ) const

inline

mean value of a component

Definition at line 34 of file GaussianSumUtilities1D.h.

{ return components()[i].mean(); }

References components(), and mps_fire::i.

Referenced by multiTrajectoryStateMode::momentumFromModePPhiEta().

mode()

const SingleGaussianState1D & GaussianSumUtilities1D::mode

(

void

)

const

Mode "state": mean = mode, variance = local variance at mode, weight chosen to have pdf(mode) equal to the one of the mixture

Definition at line 85 of file GaussianSumUtilities1D.cc.

                                                                {
  if (theModeStatus == NotComputed)
    computeMode();
  return theMode;
}

References computeMode(), NotComputed, theMode, and theModeStatus.

Referenced by computeMode(), PFGsfHelper::computeQpMode(), egamma::correctElectronMomentum(), GsfTrackProducerBase::localParametersFromQpMode(), multiTrajectoryStateMode::momentumFromModeCartesian(), multiTrajectoryStateMode::momentumFromModePPhiEta(), PFGsfHelper::PFGsfHelper(), and multiTrajectoryStateMode::positionFromModeCartesian().

modeIsValid()

bool GaussianSumUtilities1D::modeIsValid

(

)

const

mode status

Definition at line 79 of file GaussianSumUtilities1D.cc.

                                               {
  if (theModeStatus == NotComputed)
    computeMode();
  return theModeStatus == Valid;
}

References computeMode(), NotComputed, theModeStatus, and Valid.

Referenced by PFGsfHelper::computeQpMode(), GsfTrackProducerBase::localParametersFromQpMode(), and multiTrajectoryStateMode::momentumFromModePPhiEta().

pdf() [1/3]

double GaussianSumUtilities1D::pdf

(

double

x

)

const

value of the p.d.f.

Definition at line 260 of file GaussianSumUtilities1D.cc.

                                                 {
  double result(0.);
  size_t s = size();
  for (unsigned int i = 0; i < s; i++)
    result += pdf(i, x);
  return result;
}

References mps_fire::i, pdf(), mps_fire::result, alignCSCRings::s, size(), and x.

pdf() [2/3]

double GaussianSumUtilities1D::pdf ( double  , const std::vector< double > &  pdfs  )

staticprivate

value of the p.d.f. using the pdf components at the evaluation point

Definition at line 323 of file GaussianSumUtilities1D.cc.

                                                                        {
  return std::accumulate(pdfs.begin(), pdfs.end(), 0.);
}

pdf() [3/3]

double GaussianSumUtilities1D::pdf	(	unsigned int	i,
		double	x
	)		const

pdf of a single component at x

Definition at line 21 of file GaussianSumUtilities1D.cc.

                                                                 {
  return weight(i) * gauss(x, mean(i), standardDeviation(i));
}

References gauss(), mps_fire::i, mean(), standardDeviation(), weight(), and x.

Referenced by computeMode(), d1LnPdf(), d2LnPdf(), lnPdf(), localVariance(), pdf(), and update().

pdfComponents() [1/2]

std::vector< double > GaussianSumUtilities1D::pdfComponents ( const double &  x ) const

private

pdf components

Definition at line 288 of file GaussianSumUtilities1D.cc.

                                                                             {
  std::vector<double> result;
  result.reserve(size());
  for (unsigned int i = 0; i < size(); i++)
    result.push_back(weight(i) * gauss(x, mean(i), standardDeviation(i)));
  return result;
}

References gauss(), mps_fire::i, mean(), mps_fire::result, size(), standardDeviation(), and x.

Referenced by d1LnPdf(), d1Pdf(), d2LnPdf(), d2Pdf(), d3Pdf(), lnPdf(), localVariance(), and update().

pdfComponents() [2/2]

void GaussianSumUtilities1D::pdfComponents ( double  x, std::vector< double > &  result  ) const

private

pdf components

Definition at line 305 of file GaussianSumUtilities1D.cc.

                                                                                    {
  size_t s = size();
  if (s != result.size())
    result.resize(s);
  std::transform(components().begin(), components().end(), result.begin(), PDF(x));
}

References begin, components(), end, ExhumeParameters_cfi::PDF, mps_fire::result, alignCSCRings::s, size(), HcalDetIdTransform::transform(), and x.

quantile()

double GaussianSumUtilities1D::quantile

(

const double

q

)

const

Quantile (i.e. x for a given value of the c.d.f.)

Definition at line 25 of file GaussianSumUtilities1D.cc.

{ return ROOT::Math::gaussian_quantile(q, 1.); }

References data-class-funcs::q.

size()

unsigned int GaussianSumUtilities1D::size ( void  ) const

inline

number of components

Definition at line 28 of file GaussianSumUtilities1D.h.

{ return components().size(); }

References components().

Referenced by ntupleDataFormat._Collection::__iter__(), ntupleDataFormat._Collection::__len__(), cdf(), combinedMean(), computeMode(), d1Pdf(), d2Pdf(), d3Pdf(), findMode(), pdf(), and pdfComponents().

standardDeviation()

double GaussianSumUtilities1D::standardDeviation ( unsigned int  i ) const

inline

standard deviation of a component

Definition at line 36 of file GaussianSumUtilities1D.h.

                                                        {
    //     return sqrt(components()[i].variance());
    return components()[i].standardDeviation();
  }

References components(), and mps_fire::i.

Referenced by cdf(), computeMode(), d1Pdf(), d2Pdf(), d3Pdf(), pdf(), and pdfComponents().

update()

void GaussianSumUtilities1D::update ( FinderState &  state, double  x  ) const

private

Definition at line 247 of file GaussianSumUtilities1D.cc.

                                                                      {
  state.x = x;
 
  pdfComponents(state.x, state.pdfs);
  state.y = pdf(state.x, state.pdfs);
  state.yd = 0;
  if (state.y > std::numeric_limits<double>::min())
    state.yd = d1Pdf(state.x, state.pdfs) / state.y;
  state.yd2 = -state.yd * state.yd;
  if (state.y > std::numeric_limits<double>::min())
    state.yd2 += d2Pdf(state.x, state.pdfs) / state.y;
}

References d1Pdf(), d2Pdf(), min(), pdf(), pdfComponents(), GaussianSumUtilities1D::FinderState::pdfs, x, GaussianSumUtilities1D::FinderState::x, GaussianSumUtilities1D::FinderState::y, GaussianSumUtilities1D::FinderState::yd, and GaussianSumUtilities1D::FinderState::yd2.

Referenced by progressbar.ProgressBar::__next__(), MatrixUtil.Matrix::__setitem__(), MatrixUtil.Steps::__setitem__(), findMode(), progressbar.ProgressBar::finish(), and MatrixUtil.Steps::overwrite().

variance() [1/2]

double GaussianSumUtilities1D::variance ( ) const

inline

combined covariance

Definition at line 73 of file GaussianSumUtilities1D.h.

{ return theState.variance(); }

References theState, and MultiGaussianState1D::variance().

Referenced by computeMode().

variance() [2/2]

double GaussianSumUtilities1D::variance ( unsigned int  i ) const

inline

variance of a component

Definition at line 41 of file GaussianSumUtilities1D.h.

{ return components()[i].variance(); }

References components(), and mps_fire::i.

weight() [1/2]

double GaussianSumUtilities1D::weight ( ) const

inline

combined weight

Definition at line 69 of file GaussianSumUtilities1D.h.

{ return theState.weight(); }

References theState, and MultiGaussianState1D::weight().

Referenced by cdf(), combinedMean(), computeMode(), and pdf().

weight() [2/2]

double GaussianSumUtilities1D::weight ( unsigned int  i ) const

inline

weight of a component

Definition at line 32 of file GaussianSumUtilities1D.h.

{ return components()[i].weight(); }

References components(), and mps_fire::i.

Member Data Documentation

theMode

SingleGaussianState1D GaussianSumUtilities1D::theMode

mutableprivate

Definition at line 130 of file GaussianSumUtilities1D.h.

Referenced by computeMode(), and mode().

theModeStatus

ModeStatus GaussianSumUtilities1D::theModeStatus

mutableprivate

Definition at line 129 of file GaussianSumUtilities1D.h.

Referenced by computeMode(), mode(), and modeIsValid().

theState

const MultiGaussianState1D& GaussianSumUtilities1D::theState

private

Definition at line 126 of file GaussianSumUtilities1D.h.

Referenced by components(), computeMode(), mean(), variance(), and weight().