gum::Chi2 Class Reference

Represent the chi2 distribution. More...

#include <agrum/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 58 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 58 of file chi2.cpp.

                                                                 :
      __modalities(var_modalities),
      __confidence_proba(confidence_proba) {
    // for debugging purposes
    GUM_CONSTRUCTOR(Chi2);
  }

~Chi2()

gum::Chi2::~Chi2

(

)

Class destructor.

Definition at line 67 of file chi2.cpp.

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

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

References probaChi2().

Referenced by criticalValue().

                                                    {
    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:

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

Referenced by probaChi2().

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

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

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

References __confidence_proba, __critical_values, __criticalValue(), degreesOfFreedom(), and gum::HashTable< Key, Val, Alloc >::insert().

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

Referenced by criticalValue().

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

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

References __conditioning_size, and __modalities.

                                                       {
    return (__conditioning_size * (__modalities[var1] - 1)
            * (__modalities[var2] - 1));
  }

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

References __probaZValue().

Referenced by __criticalValue().

                                          {
    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:

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

References __conditioning_size, and __modalities.

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

setConfidenceProba()

INLINE void gum::Chi2::setConfidenceProba

(

double

new_proba

)

Modifies the confidence probability.

Parameters

new_proba

The new confidence probability

Definition at line 78 of file chi2_inl.h.

References __confidence_proba, __critical_values, and gum::HashTable< Key, Val, Alloc >::clear().

                                                       {
    // 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 158 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 155 of file chi2.h.

Referenced by criticalValue(), and setConfidenceProba().

__critical_values

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

private

A set of already computed critical values.

Definition at line 161 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 152 of file chi2.h.

Referenced by degreesOfFreedom(), and setConditioningNodes().

---

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

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