gum::Chi2 Class Reference

Represent the chi2 distribution. More...

#include <agrum/tools/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. More...
	~Chi2 ()
	Class destructor. More...

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

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 57 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 56 of file chi2.cpp.

References gum::Set< Key, Alloc >::emplace().

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

Here is the call graph for this function:

~Chi2()

gum::Chi2::~Chi2

(

)

Class destructor.

Definition at line 63 of file chi2.cpp.

References gum::Set< Key, Alloc >::emplace().

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

Here is the call graph for this function:

Chi2() [2/2]

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

privatedelete

Forbid use of the copy constructor.

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 173 of file chi2.cpp.

References gum::Set< Key, Alloc >::emplace().

                                                    {
    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);
  }

Here is the call 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 69 of file chi2.cpp.

References gum::Set< Key, Alloc >::emplace().

                                     {
    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));
  }

Here is the call 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 54 of file chi2_inl.h.

References gum::Set< Key, Alloc >::emplace().

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

Here is the call 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 59 of file chi2_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                                             {
    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;
    }
  }

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 44 of file chi2_inl.h.

References gum::Set< Key, Alloc >::emplace().

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

Here is the call 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 49 of file chi2_inl.h.

References gum::Set< Key, Alloc >::emplace().

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

Here is the call graph for this function:

operator=()

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

privatedelete

Forbid used of the copy operator.

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 126 of file chi2.cpp.

References gum::Set< Key, Alloc >::emplace().

                                          {
    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);
  }

Here is the call 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 36 of file chi2_inl.h.

References gum::Set< Key, Alloc >::emplace().

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

Here is the call graph for this function:

setConfidenceProba()

INLINE void gum::Chi2::setConfidenceProba

(

double

new_proba

)

Modifies the confidence probability.

Parameters

new_proba

The new confidence probability

Definition at line 75 of file chi2_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                                       {
    // 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();
  }

Here is the call graph for this function:

Member Data Documentation

_conditioning_size_

Size gum::Chi2::_conditioning_size_

private

The domain size of the conditioning nodes.

Definition at line 157 of file chi2.h.

_confidence_proba_

double gum::Chi2::_confidence_proba_

private

The confidence probability used for critical values.

Definition at line 154 of file chi2.h.

_critical_values_

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

private

A set of already computed critical values.

Definition at line 160 of file chi2.h.

_modalities_

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

private

The modalities of the random variables.

Definition at line 151 of file chi2.h.

---

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

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