#include <BinomialInterval.h>

Inheritance diagram for BinomialInterval:

Public Types
enum	tail_type { equal_tailed, lower_tailed, upper_tailed }
Public Member Functions
double	alpha () const
virtual void	calculate (const double successes, const double trials)=0
bool	contains (double rho)
double	coverage_prob (const double rho, const int trials)
void	dump (const int trials_min, const int trials_max)
void	init (const double alpha, const tail_type t=equal_tailed)
double	length () const
double	lower () const
virtual const char *	name () const =0
virtual bool	neyman (const int ntot, const int nrho, double rho, double x_l, double *x_r)
void	scan_ntot (const double rho, const int ntot_min, const int ntot_max, double ntot, double prob)
void	scan_rho (const int ntot, const int nrho, double rho, double prob)
double	upper () const
Protected Member Functions
void	set (double l, double u)
Protected Attributes
double	alpha_
double	alpha_min_
double	kappa2_
double	kappa_
double	lower_
tail_type	type_
double	upper_

Detailed Description

Definition at line 18 of file BinomialInterval.h.

Member Enumeration Documentation

enum BinomialInterval::tail_type

Enumerator:

equal_tailed
lower_tailed
upper_tailed

Definition at line 27 of file BinomialInterval.h.

{ equal_tailed, lower_tailed, upper_tailed };

Member Function Documentation

double BinomialInterval::alpha ( void ) const [inline]

Definition at line 77 of file BinomialInterval.h.

References alpha_.

Referenced by ClassImp().

{ return alpha_; }

virtual void BinomialInterval::calculate	(	const double	successes,
		const double	trials
	)		`[pure virtual]`

Implemented in BinomialNoncentralInterval< Sorter >, ClopperPearsonBinomialInterval, BinomialNoncentralInterval< SterneSorter >, and BinomialNoncentralInterval< FeldmanCousinsSorter >.

Referenced by coverage_prob(), and dump().

bool BinomialInterval::contains ( double rho )

Definition at line 22 of file BinomialInterval.cc.

References lower_, lower_tailed, type_, upper_, and upper_tailed.

Referenced by coverage_prob().

                                        {
  if (type_ == upper_tailed)
    return p <= upper_;
  else if (type_ == lower_tailed)
    return p >= lower_;
  else //if (type_ == equal_tailed)
    return p >= lower_ && p <= upper_;
}

double BinomialInterval::coverage_prob	(	const double	rho,
		const int	trials
	)

Definition at line 31 of file BinomialInterval.cc.

References calculate(), contains(), and X.

Referenced by scan_ntot(), and scan_rho().

                                                                       {
  double prob = 0;

  for (int X = 0; X <= trials; ++X) {
    calculate(X, trials);

    if (contains(p))
      prob += ROOT::Math::binomial_pdf(X, p, trials);
  }
  
  return prob;
}

void BinomialInterval::dump	(	const int	trials_min,
		const int	trials_max
	)

Definition at line 60 of file BinomialInterval.cc.

References calculate(), lower_, n, name(), upper_, and X.

                                                                      {
  const std::string fn = std::string("table.") + name() + std::string(".txt");
  FILE* fdump = fopen(fn.c_str(), "wt");

  for (int n = trials_min; n <= trials_max; ++n) {
    for (int X = 0; X <= n; X++) {
      calculate(X, n);
      fprintf(fdump, "%i %i %f %f\n", X, n, lower_, upper_);
    }
    fprintf(fdump, "\n");
  }

  fclose(fdump);
}

void BinomialInterval::init	(	const double	alpha,
		const tail_type	t = `equal_tailed`
	)

double BinomialInterval::length ( ) const [inline]

Definition at line 80 of file BinomialInterval.h.

References lower_, and upper_.

{ return upper_ - lower_; }

double BinomialInterval::lower ( ) const [inline]

Definition at line 78 of file BinomialInterval.h.

References lower_.

{ return lower_; }

virtual const char* BinomialInterval::name ( ) const [pure virtual]

Implemented in ClopperPearsonBinomialInterval, FeldmanCousinsBinomialInterval, and SterneBinomialInterval.

Referenced by dump().

virtual bool BinomialInterval::neyman	(	const int	ntot,
		const int	nrho,
		double *	rho,
		double *	x_l,
		double *	x_r
	)		`[inline, virtual]`

Reimplemented in BinomialNoncentralInterval< Sorter >, BinomialNoncentralInterval< SterneSorter >, and BinomialNoncentralInterval< FeldmanCousinsSorter >.

Definition at line 69 of file BinomialInterval.h.

{ return false; }

void BinomialInterval::scan_ntot	(	const double	rho,
		const int	ntot_min,
		const int	ntot_max,
		double *	ntot,
		double *	prob
	)

Definition at line 51 of file BinomialInterval.cc.

References coverage_prob(), i, and nt.

                                                              {
  for (int i = 0; i < ntot_max - ntot_min + 1; ++i) {
    int nt = i + ntot_min;
    ntot[i] = nt;
    prob[i] = coverage_prob(rho, nt);
  }
}

void BinomialInterval::scan_rho	(	const int	ntot,
		const int	nrho,
		double *	rho,
		double *	prob
	)

Definition at line 44 of file BinomialInterval.cc.

References coverage_prob(), and i.

                                                                                         {
  for (int i = 0; i < nrho; ++i) {
    rho[i]  = double(i)/nrho;
    prob[i] = coverage_prob(rho[i], ntot);
  }
}