BinomialNoncentralInterval< Sorter > Class Template Reference

#include <BinomialNoncentralInterval.h>

Inheritance diagram for BinomialNoncentralInterval< Sorter >:

Public Member Functions
void	calculate (const double X, const double n) override
bool	find_rho_set (const double rho, const int ntot, int &x_l, int &x_r) const
bool	neyman (const int ntot, const int nrho, double *rho, double *x_l, double *x_r) override
Public Member Functions inherited from BinomialInterval
double	alpha () const
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
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
virtual	~BinomialInterval ()=default

Private Attributes
Sorter	sorter_

Additional Inherited Members
Public Types inherited from BinomialInterval
enum	tail_type { equal_tailed, lower_tailed, upper_tailed }
Protected Member Functions inherited from BinomialInterval
void	set (double l, double u)
Protected Attributes inherited from BinomialInterval
double	alpha_
double	alpha_min_
double	kappa2_
double	kappa_
double	lower_
tail_type	type_
double	upper_

Detailed Description

template<typename Sorter>
class BinomialNoncentralInterval< Sorter >

Definition at line 31 of file BinomialNoncentralInterval.h.

Member Function Documentation

template<typename Sorter>

void BinomialNoncentralInterval< Sorter >::calculate ( const double  X, const double  n  )

inlineoverridevirtual

Implements BinomialInterval.

Definition at line 78 of file BinomialNoncentralInterval.h.

                                                          {
    set(0, 1);

    const double tol = 1e-9;
    double rho_min, rho_max, rho;
    int x_l, x_r;
  
    // Binary search for the smallest rho whose acceptance set has right
    // endpoint X; this is the lower endpoint of the rho interval.
    rho_min = 0; rho_max = 1;
    while (std::fabs(rho_max - rho_min) > tol) {
      rho = (rho_min + rho_max)/2;
      find_rho_set(rho, int(n), x_l, x_r);
      if (x_r < X)
    rho_min = rho;
      else
    rho_max = rho;
    }
    lower_ = rho;
  
    // Binary search for the largest rho whose acceptance set has left
    // endpoint X; this is the upper endpoint of the rho interval.
    rho_min = 0; rho_max = 1;
    while (std::fabs(rho_max - rho_min) > tol) {
      rho = (rho_min + rho_max)/2;
      find_rho_set(rho, int(n), x_l, x_r);
      if (x_l > X)
    rho_max = rho;
      else
    rho_min = rho;
    }
    upper_ = rho;
  }

template<typename Sorter>

bool BinomialNoncentralInterval< Sorter >::find_rho_set ( const double  rho, const int  ntot, int &  x_l, int &  x_r  ) const

inline

Definition at line 35 of file BinomialNoncentralInterval.h.

Referenced by BinomialNoncentralInterval< FeldmanCousinsSorter >::calculate(), and BinomialNoncentralInterval< FeldmanCousinsSorter >::neyman().

                                                                                {
    // Get the binomial probabilities for every x = 0..n, and sort them
    // in decreasing order, determined by the Sorter class.
    std::vector<BinomialProbHelper> probs;
    for (int i = 0; i <= ntot; ++i)
      probs.push_back(BinomialProbHelper(rho, i, ntot));
    std::sort(probs.begin(), probs.end(), sorter_);

    // Add up the probabilities until the total is 1 - alpha or
    // bigger, adding the biggest point first, then the next biggest,
    // etc. "Biggest" is given by the Sorter class and is taken care
    // of by the sort above. JMTBAD need to find equal probs and use
    // the sorter to differentiate between them.
    const double target = 1 - alpha_;
    // An invalid interval.
    x_l = ntot;
    x_r = 0;
    double sum = 0;
    for (int i = 0; i <= ntot && sum < target; ++i) {
      sum += probs[i].prob();
      const int& x = probs[i].x();
      if (x < x_l) x_l = x;
      if (x > x_r) x_r = x;
    }
  
    return x_l <= x_r;
  }

template<typename Sorter>

bool BinomialNoncentralInterval< Sorter >::neyman ( const int  ntot, const int  nrho, double *  rho, double *  x_l, double *  x_r  )

inlineoverridevirtual

Reimplemented from BinomialInterval.

Definition at line 65 of file BinomialNoncentralInterval.h.

                                                                                              {
    int xL, xR;
    for (int i = 0; i < nrho; ++i) {
      rho[i] = double(i)/nrho;
      find_rho_set(rho[i], ntot, xL, xR);
      x_l[i] = xL;
      x_r[i] = xR;
    }
    return true;
  }

Member Data Documentation

template<typename Sorter>

Sorter BinomialNoncentralInterval< Sorter >::sorter_

private

Definition at line 113 of file BinomialNoncentralInterval.h.

Referenced by BinomialNoncentralInterval< FeldmanCousinsSorter >::find_rho_set().