gum::Chi2 Class Reference

Represent the chi2 distribution. More...

#include <agrum/base/core/math/chi2.h>

Collaboration diagram for gum::Chi2:

Public Member Functions
Constructors / Destructors
	Chi2 (const std::vector< std::size_t > &var_modalities, double confidence_proba=GUM_LEARNING_CONFIDENCE_PROBA)
	Default constructor.
	~Chi2 ()
	Class destructor.

Private Member Functions
	Chi2 (const Chi2 &)=delete
	Forbid use of the copy constructor.
Chi2 &	operator= (const Chi2 &)=delete
	Forbid used of the copy operator.

Static Private Member Functions
static double	_criticalValue_ (double proba, Size df)
	Computes the critical value of a given chi2 test (used by the cache).
static double	_probaZValue_ (double z)
	Computes the probability of normal z value.

Private Attributes
const std::vector< std::size_t > &	_modalities_
	The modalities of the random variables.
double	_confidence_proba_
	The confidence probability used for critical values.
Size	_conditioning_size_
	The domain size of the conditioning nodes.
HashTable< Idx, double >	_critical_values_
	A set of already computed critical values.

Accessors / Modifiers
void	setConditioningNodes (const std::vector< Idx > &db_conditioning_ids)
	Sets the conditioning nodes (useful for computing degrees of freedom).
double	criticalValue (const std::pair< Idx, Idx > &pair)
	Computes the critical value according to the number of degrees of freedom.
double	criticalValue (Idx var1, Idx var2)
	Computes the critical value according to the number of degrees of freedom.
Size	degreesOfFreedom (const std::pair< Idx, Idx > &pair)
	Returns the number of degrees of freedom.
Size	degreesOfFreedom (Idx var1, Idx var2)
	Returns the number of degrees of freedom.
void	setConfidenceProba (double new_proba)
	Modifies the confidence probability.
static double	probaChi2 (double x, Size df)
	Computes the probability of chi2 value.

Detailed Description

Represent the chi2 distribution.

The class constructor receives a std::vector of unsigned integers. This std::vector represents the variables modalities. The variables indexes in the std::vector will be used as the variables identifiers.

Definition at line 79 of file chi2.h.

Constructor & Destructor Documentation

Chi2() [1/2]

gum::Chi2::Chi2	(	const std::vector< std::size_t > &	var_modalities,
		double	confidence_proba = GUM_LEARNING_CONFIDENCE_PROBA )

Default constructor.

Parameters

var_modalities	The variables modalities.
confidence_proba	The confidence probability.

Definition at line 76 of file chi2.cpp.

                                                                                  :
      _modalities_(var_modalities),
      _confidence_proba_(confidence_proba) {   // for debugging purposes
    GUM_CONSTRUCTOR(Chi2);
  }

References Chi2(), _confidence_proba_, and _modalities_.

Referenced by Chi2(), Chi2(), ~Chi2(), and operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

~Chi2()

gum::Chi2::~Chi2

(

)

Class destructor.

Definition at line 83 of file chi2.cpp.

              {
    // for debugging purposes
    GUM_DESTRUCTOR(Chi2);
  }

References Chi2().

Here is the call graph for this function:

Chi2() [2/2]

gum::Chi2::Chi2 ( const Chi2 & )

privatedelete

Forbid use of the copy constructor.

References Chi2().

Here is the call graph for this function:

Member Function Documentation

_criticalValue_()

double gum::Chi2::_criticalValue_ ( double proba, Size df )

staticprivate

Computes the critical value of a given chi2 test (used by the cache).

This code has been written by Gary Perlman.

Parameters

proba	The probability value.
df	The number of degrees of freedom.

Returns

Returns the critical value of a given chi2 test.

Definition at line 190 of file chi2.cpp.

                                                    {
    double minchisq = 0.0;
    double maxchisq = GUM_CHI_MAX;
    double chisqval;
 
    if (proba <= 0.0) return (maxchisq);
    else if (proba >= 1.0) return (0.0);
 
    chisqval = df / std::sqrt(proba); /* fair first value */
 
    while (maxchisq - minchisq > GUM_CHI_EPSILON) {
      if (probaChi2(chisqval, df) < proba) maxchisq = chisqval;
      else minchisq = chisqval;
 
      chisqval = (maxchisq + minchisq) * 0.5;
    }
 
    return (chisqval);
  }

References probaChi2().

Referenced by criticalValue().

Here is the call graph for this function:

Here is the caller graph for this function:

_probaZValue_()

double gum::Chi2::_probaZValue_ ( double z )

staticprivate

Computes the probability of normal z value.

This code has been written by Gary Perlman.

ALGORITHM Adapted from a polynomial approximation in: Ibbetson D, Algorithm 209 Collected Algorithms of the CACM 1963 p. 616

This routine has six digit accuracy, so it is only useful for absolute z values < 6. For z values >= to 6.0, probaZValue() returns 0.0.

Parameters

z

A value.

Returns

The probability of z.

Definition at line 89 of file chi2.cpp.

                                     {
    double y, x, w;
 
    if (z == 0.0) x = 0.0;
    else {
      y = 0.5 * std::fabs(z);
 
      if (y >= (GUM_Z_MAX * 0.5)) x = 1.0;
      else if (y < 1.0) {
        w = y * y;
        x = ((((((((0.000124818987 * w - 0.001075204047) * w + 0.005198775019) * w - 0.019198292004)
                     * w
                 + 0.059054035642)
                    * w
                - 0.151968751364)
                   * w
               + 0.319152932694)
                  * w
              - 0.531923007300)
                 * w
             + 0.797884560593)
          * y * 2.0;
      } else {
        y -= 2.0;
        x = (((((((((((((-0.000045255659 * y + 0.000152529290) * y - 0.000019538132) * y
                       - 0.000676904986)
                          * y
                      + 0.001390604284)
                         * y
                     - 0.000794620820)
                        * y
                    - 0.002034254874)
                       * y
                   + 0.006549791214)
                      * y
                  - 0.010557625006)
                     * y
                 + 0.011630447319)
                    * y
                - 0.009279453341)
                   * y
               + 0.005353579108)
                  * y
              - 0.002141268741)
                 * y
             + 0.000535310849)
              * y
          + 0.999936657524;
      }
    }
 
    return (z > 0.0 ? ((x + 1.0) * 0.5) : ((1.0 - x) * 0.5));
  }

Referenced by probaChi2().

Here is the caller graph for this function:

criticalValue() [1/2]

ALWAYS_INLINE double gum::Chi2::criticalValue

(

const std::pair< Idx, Idx > &

pair

)

Computes the critical value according to the number of degrees of freedom.

Parameters

pair	A pair of variables ids.

Returns

Returns the critical values.

Definition at line 74 of file chi2_inl.h.

                                                                          {
    return criticalValue(pair.first, pair.second);
  }

References criticalValue().

Referenced by criticalValue().

Here is the call graph for this function:

Here is the caller graph for this function:

criticalValue() [2/2]

ALWAYS_INLINE double gum::Chi2::criticalValue	(	Idx	var1,
		Idx	var2 )

Computes the critical value according to the number of degrees of freedom.

Parameters

var1	The first variable id.
var2	The second variable id.

Returns

Returns the critical value.

Definition at line 79 of file chi2_inl.h.

                                                             {
    Size DF = degreesOfFreedom(var1, var2);
 
    // try to see if the threshold is not already in cache
    try {
      return _critical_values_[DF];
    } catch (const Exception&) {
      // here we have to compute the threshold of the chi2
      // we use Gary Perlman's algorithm
      double value = _criticalValue_(_confidence_proba_, DF);
      _critical_values_.insert(DF, value);
      return value;
    }
  }

References _confidence_proba_, _critical_values_, _criticalValue_(), and degreesOfFreedom().

Here is the call graph for this function:

degreesOfFreedom() [1/2]

INLINE Size gum::Chi2::degreesOfFreedom

(

const std::pair< Idx, Idx > &

pair

)

Returns the number of degrees of freedom.

Parameters

pair	A pair of variables ids.

Returns

Returns the number of degrees of freedom.

Definition at line 64 of file chi2_inl.h.

                                                                    {
    return degreesOfFreedom(pair.first, pair.second);
  }

References degreesOfFreedom().

Referenced by criticalValue(), and degreesOfFreedom().

Here is the call graph for this function:

Here is the caller graph for this function:

degreesOfFreedom() [2/2]

INLINE Size gum::Chi2::degreesOfFreedom	(	Idx	var1,
		Idx	var2 )

Returns the number of degrees of freedom.

Parameters

var1	The first variable id.
var2	The second variable id.

Returns

Returns the number of degrees of freedom.

Definition at line 69 of file chi2_inl.h.

                                                       {
    return (_conditioning_size_ * (_modalities_[var1] - 1) * (_modalities_[var2] - 1));
  }

References _conditioning_size_, and _modalities_.

operator=()

Chi2 & gum::Chi2::operator= ( const Chi2 & )

privatedelete

Forbid used of the copy operator.

References Chi2().

Here is the call graph for this function:

probaChi2()

double gum::Chi2::probaChi2 ( double x, Size df )

static

Computes the probability of chi2 value.

This code has been written by Gary Perlman.

ALGORITHM Compute probability of chi square value. Adapted from: Hill, I. D. and Pike, M. C. Algorithm 299 Collected Algorithms for the CACM 1967 p. 243 Updated for rounding errors based on remark in ACM TOMS June 1985, page 185

Parameters

x	The chi2 value.
df	The number of degrees of freedom.

Returns

The probability of x given df degrees of freedom.

Definition at line 144 of file chi2.cpp.

                                          {
    double a, y = 0, s;
    double e, c, z;
    int    even; /* true if df is an even number */
 
    if ((x <= 0.0) || (df < 1)) return (1.0);
 
    a = 0.5 * x;
 
    even = (2 * (df / 2)) == df;
 
    if (df > 1) y = _gum_ex(-a);
 
    s = (even ? y : (2.0 * _probaZValue_(-std::sqrt(x))));
 
    if (df > 2) {
      x = 0.5 * (df - 1.0);
      z = (even ? 1.0 : 0.5);
 
      if (a > GUM_BIGX) {
        e = (even ? 0.0 : GUM_LOG_SQRT_PI);
        c = std::log(a);
 
        while (z <= x) {
          e = std::log(z) + e;
          s += _gum_ex(c * z - a - e);
          z += 1.0;
        }
 
        return (s);
      } else {
        e = (even ? 1.0 : (GUM_I_SQRT_PI / std::sqrt(a)));
        c = 0.0;
 
        while (z <= x) {
          e = e * (a / z);
          c = c + e;
          z += 1.0;
        }
 
        return (c * y + s);
      }
    } else return (s);
  }

References _probaZValue_().

Referenced by _criticalValue_().

Here is the call graph for this function:

Here is the caller graph for this function:

setConditioningNodes()

INLINE void gum::Chi2::setConditioningNodes

(

const std::vector< Idx > &

db_conditioning_ids

)

Sets the conditioning nodes (useful for computing degrees of freedom).

Parameters

db_conditioning_ids

The conditioning nodes id.

Definition at line 56 of file chi2_inl.h.

                                                                                    {
    _conditioning_size_ = 1;
    for (Idx i = 0; i < db_conditioning_ids.size(); ++i) {
      _conditioning_size_ *= _modalities_[db_conditioning_ids[i]];
    }
  }

References _conditioning_size_, and _modalities_.

setConfidenceProba()

INLINE void gum::Chi2::setConfidenceProba

(

double

new_proba

)

Modifies the confidence probability.

Parameters

new_proba

The new confidence probability

Definition at line 95 of file chi2_inl.h.

                                                       {
    // if we did not change the confidence proba, do nothing
    if (_confidence_proba_ == new_proba) return;
 
    _confidence_proba_ = new_proba;
 
    // remove the currently stored critical values
    _critical_values_.clear();
  }

References _confidence_proba_, and _critical_values_.

Member Data Documentation

_conditioning_size_

Size gum::Chi2::_conditioning_size_

private

The domain size of the conditioning nodes.

Definition at line 179 of file chi2.h.

Referenced by degreesOfFreedom(), and setConditioningNodes().

_confidence_proba_

double gum::Chi2::_confidence_proba_

private

The confidence probability used for critical values.

Definition at line 176 of file chi2.h.

Referenced by Chi2(), criticalValue(), and setConfidenceProba().

_critical_values_

HashTable< Idx, double > gum::Chi2::_critical_values_

private

A set of already computed critical values.

Definition at line 182 of file chi2.h.

Referenced by criticalValue(), and setConfidenceProba().

_modalities_

const std::vector< std::size_t >& gum::Chi2::_modalities_

private

The modalities of the random variables.

Definition at line 173 of file chi2.h.

Referenced by Chi2(), degreesOfFreedom(), and setConditioningNodes().

---

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

• agrum/base/core/math/chi2.h
• agrum/base/core/math/chi2.cpp
• agrum/base/core/math/chi2_inl.h