InformationTheory is a template class which aims at gathering the implementation of informational functions (entropy, mutual information, etc.). More...

#include <informationTheory.h>

Collaboration diagram for gum::InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >:

[legend]

Public Member Functions
	InformationTheory (INFERENCE_ENGINE< GUM_SCALAR > &engine, NodeSet X, NodeSet Y, NodeSet Z)
	InformationTheory (INFERENCE_ENGINE< GUM_SCALAR > &engine, const NodeSet &X, const NodeSet &Y)
	InformationTheory (INFERENCE_ENGINE< GUM_SCALAR > &engine, const std::vector< std::string > &Xnames, const std::vector< std::string > &Ynames)
	InformationTheory (INFERENCE_ENGINE< GUM_SCALAR > &engine, const std::vector< std::string > &Xnames, const std::vector< std::string > &Ynames, const std::vector< std::string > &Znames)
	~InformationTheory ()
GUM_SCALAR	entropyXY ()
GUM_SCALAR	entropyX ()
GUM_SCALAR	entropyY ()
GUM_SCALAR	entropyXgivenY ()
GUM_SCALAR	entropyYgivenX ()
GUM_SCALAR	mutualInformationXY ()
GUM_SCALAR	variationOfInformationXY ()
GUM_SCALAR	entropyXgivenZ ()
GUM_SCALAR	entropyYgivenZ ()
GUM_SCALAR	entropyXYgivenZ ()
GUM_SCALAR	entropyXgivenYZ ()
GUM_SCALAR	mutualInformationXYgivenZ ()

Protected Member Functions
void	makeInference_ ()

Protected Attributes
INFERENCE_ENGINE< GUM_SCALAR > &	engine_
const NodeSet	X_
const NodeSet	Y_
const NodeSet	Z_
VariableSet	vX_
VariableSet	vY_
VariableSet	vZ_
Tensor< GUM_SCALAR >	pXYZ_
Tensor< GUM_SCALAR >	pXY_
Tensor< GUM_SCALAR >	pXZ_
Tensor< GUM_SCALAR >	pYZ_
Tensor< GUM_SCALAR >	pX_
Tensor< GUM_SCALAR >	pY_
Tensor< GUM_SCALAR >	pZ_

Detailed Description

template<template< typename > class INFERENCE_ENGINE, typename GUM_SCALAR>
class gum::InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >

InformationTheory is a template class which aims at gathering the implementation of informational functions (entropy, mutual information, etc.).

All these operations start with the inference of a joint distribution. Moreover, it is possible to want to condition these calculations. The inference (able to compute joint distributions) passed as an argument can therefore have previously defined evidence.

Warning: The joint distribution underlying the computations has a definition domain of exponential size depending on the number of variables passed as arguments. One must be aware of the complexity of the inference that will initially be carried out.

Note: All computations are made with std::log2

Template Parameters

INFERENCE_ENGINE	: the inference engine
GUM_SCALAR	: the numeric type of parameters

Definition at line 83 of file informationTheory.h.

Constructor & Destructor Documentation

◆ InformationTheory() [1/4]

template<template< typename > class INFERENCE_ENGINE, typename GUM_SCALAR>

INFORMATION_THEORY_TEMPLATE gum::InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::InformationTheory	(	INFERENCE_ENGINE< GUM_SCALAR > &	engine,
		gum::NodeSet	X,
		gum::NodeSet	Y,
		gum::NodeSet	Z )

Definition at line 63 of file informationTheory_tpl.h.

                    : engine_(engine), X_(std::move(X)), Y_(std::move(Y)), Z_(std::move(Z)) {
    GUM_CONSTRUCTOR(InformationTheory)
    if ((!(X_ * Y_).empty()) || (!(X_ * Z_).empty()) || (!(Z_ * Y_).empty()))
      GUM_ERROR(OperationNotAllowed, "The intersection between the set of variables must be empty")
    makeInference_();
  }

References InformationTheory(), engine_, GUM_ERROR, makeInference_(), X_, Y_, and Z_.

Referenced by InformationTheory(), InformationTheory(), InformationTheory(), InformationTheory(), and ~InformationTheory().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ InformationTheory() [2/4]

template<template< typename > class INFERENCE_ENGINE, typename GUM_SCALAR>

INFORMATION_THEORY_TEMPLATE gum::InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::InformationTheory	(	INFERENCE_ENGINE< GUM_SCALAR > &	engine,
		const NodeSet &	X,
		const NodeSet &	Y )

Definition at line 75 of file informationTheory_tpl.h.

78 : InformationTheory(engine, X, Y, NodeSet()) {}

References InformationTheory().

Here is the call graph for this function:

◆ InformationTheory() [3/4]

template<template< typename > class INFERENCE_ENGINE, typename GUM_SCALAR>

INFORMATION_THEORY_TEMPLATE gum::InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::InformationTheory	(	INFERENCE_ENGINE< GUM_SCALAR > &	engine,
		const std::vector< std::string > &	Xnames,
		const std::vector< std::string > &	Ynames )

Definition at line 81 of file informationTheory_tpl.h.

                                            :
      InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >(engine,
                                                        engine.model().nodeset(Xnames),
                                                        engine.model().nodeset(Ynames),
                                                        NodeSet()) {}

References InformationTheory().

Here is the call graph for this function:

◆ InformationTheory() [4/4]

template<template< typename > class INFERENCE_ENGINE, typename GUM_SCALAR>

INFORMATION_THEORY_TEMPLATE gum::InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::InformationTheory	(	INFERENCE_ENGINE< GUM_SCALAR > &	engine,
		const std::vector< std::string > &	Xnames,
		const std::vector< std::string > &	Ynames,
		const std::vector< std::string > &	Znames )

Definition at line 91 of file informationTheory_tpl.h.

                                            :
      InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >(engine,
                                                        engine.model().nodeset(Xnames),
                                                        engine.model().nodeset(Ynames),
                                                        engine.model().nodeset(Znames)) {}

References InformationTheory().

Here is the call graph for this function:

◆ ~InformationTheory()

template<template< typename > class INFERENCE_ENGINE, typename GUM_SCALAR>

INFORMATION_THEORY_TEMPLATE gum::InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::~InformationTheory ( )

Definition at line 102 of file informationTheory_tpl.h.

                                                                        {
    GUM_DESTRUCTOR(InformationTheory);
  }

References InformationTheory().

Here is the call graph for this function:

Member Function Documentation

◆ entropyX()

template<template< typename > class INFERENCE_ENGINE, typename GUM_SCALAR>

INFORMATION_THEORY_TEMPLATE GUM_SCALAR gum::InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::entropyX ( )

Definition at line 151 of file informationTheory_tpl.h.

151{ return pX_.entropy(); }

gum::InformationTheory::pX_

Tensor< GUM_SCALAR > pX_

Definition informationTheory.h:130

References pX_.

◆ entropyXgivenY()

template<template< typename > class INFERENCE_ENGINE, typename GUM_SCALAR>

INFORMATION_THEORY_TEMPLATE GUM_SCALAR gum::InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::entropyXgivenY ( )

Definition at line 162 of file informationTheory_tpl.h.

                                                                               {
    return -pXY_.expectedValue([this](const gum::Instantiation& i) -> GUM_SCALAR {
      // f(x,y)=log (p(x,y)/p(y))
      const auto& pxy = pXY_[i];
      if (pxy == GUM_SCALAR(0.0)) return GUM_SCALAR(0.0);
 
      const auto& py = pY_[i];
      if (py == GUM_SCALAR(0.0)) return GUM_SCALAR(0.0);
 
      return GUM_LOG2_OR_0(pxy / py);
    });
  }

References GUM_LOG2_OR_0, pXY_, and pY_.

◆ entropyXgivenYZ()

template<template< typename > class INFERENCE_ENGINE, typename GUM_SCALAR>

INFORMATION_THEORY_TEMPLATE GUM_SCALAR gum::InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::entropyXgivenYZ ( )

Definition at line 257 of file informationTheory_tpl.h.

                                                                                {
    if (Z_.empty()) GUM_ERROR(ArgumentError, "Z has not been specified.")
    return pXYZ_.expectedValue([this](const gum::Instantiation& i) -> GUM_SCALAR {
      // f(x,y,z)= -log(p(x,y,z)/p(y,z))
      const auto& pxyz = pXYZ_[i];
      if (pxyz == GUM_SCALAR(0.0)) return GUM_SCALAR(0.0);
 
      const auto& pyz = pYZ_[i];
      if (pyz == GUM_SCALAR(0.0)) return GUM_SCALAR(0.0);
 
      return -GUM_LOG2_OR_0(pxyz / pyz);
    });
  }

References GUM_ERROR, GUM_LOG2_OR_0, pXYZ_, pYZ_, and Z_.

◆ entropyXgivenZ()

template<template< typename > class INFERENCE_ENGINE, typename GUM_SCALAR>

INFORMATION_THEORY_TEMPLATE GUM_SCALAR gum::InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::entropyXgivenZ ( )

Definition at line 190 of file informationTheory_tpl.h.

                                                                               {
    if (Z_.empty()) GUM_ERROR(ArgumentError, "Z has not been specified.")
    return -pXZ_.expectedValue([this](const gum::Instantiation& i) -> GUM_SCALAR {
      // f(x,z)=log (p(x,z)/p(z))
      const auto& pxz = pXZ_[i];
      if (pxz == GUM_SCALAR(0.0)) return GUM_SCALAR(0.0);
 
      const auto& pz = pZ_[i];
      if (pz == GUM_SCALAR(0.0)) return GUM_SCALAR(0.0);
 
      return GUM_LOG2_OR_0(pxz / pz);
    });
  }

References GUM_ERROR, GUM_LOG2_OR_0, pXZ_, pZ_, and Z_.

◆ entropyXY()

template<template< typename > class INFERENCE_ENGINE, typename GUM_SCALAR>

INFORMATION_THEORY_TEMPLATE GUM_SCALAR gum::InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::entropyXY ( )

Definition at line 157 of file informationTheory_tpl.h.

                                                                          {
    return pXY_.entropy();
  }

References pXY_.

◆ entropyXYgivenZ()

template<template< typename > class INFERENCE_ENGINE, typename GUM_SCALAR>

INFORMATION_THEORY_TEMPLATE GUM_SCALAR gum::InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::entropyXYgivenZ ( )

Definition at line 242 of file informationTheory_tpl.h.

                                                                                {
    if (Z_.empty()) GUM_ERROR(ArgumentError, "Z has not been specified.")
    return pXYZ_.expectedValue([this](const gum::Instantiation& i) -> GUM_SCALAR {
      // f(x,y,z)= -log(p(x,y,z)/p(z))
      const auto& pxyz = pXYZ_[i];
      if (pxyz == GUM_SCALAR(0.0)) return GUM_SCALAR(0.0);
 
      const auto& pz = pZ_[i];
      if (pz == GUM_SCALAR(0.0)) return GUM_SCALAR(0.0);
 
      return -GUM_LOG2_OR_0(pxyz / pz);
    });
  }

References GUM_ERROR, GUM_LOG2_OR_0, pXYZ_, pZ_, and Z_.

◆ entropyY()

template<template< typename > class INFERENCE_ENGINE, typename GUM_SCALAR>

INFORMATION_THEORY_TEMPLATE GUM_SCALAR gum::InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::entropyY ( )

Definition at line 154 of file informationTheory_tpl.h.

154{ return pY_.entropy(); }

References pY_.

◆ entropyYgivenX()

template<template< typename > class INFERENCE_ENGINE, typename GUM_SCALAR>

INFORMATION_THEORY_TEMPLATE GUM_SCALAR gum::InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::entropyYgivenX ( )

Definition at line 176 of file informationTheory_tpl.h.

                                                                               {
    return -pXY_.expectedValue([this](const gum::Instantiation& i) -> GUM_SCALAR {
      // f(x,y)=log (p(x,y)/p(x))
      const auto& pxy = pXY_[i];
      if (pxy == GUM_SCALAR(0.0)) return GUM_SCALAR(0.0);
 
      const auto& px = pX_[i];
      if (px == GUM_SCALAR(0.0)) return GUM_SCALAR(0.0);
 
      return GUM_LOG2_OR_0(pxy / px);
    });
  }

References GUM_LOG2_OR_0, pX_, and pXY_.

◆ entropyYgivenZ()

template<template< typename > class INFERENCE_ENGINE, typename GUM_SCALAR>

INFORMATION_THEORY_TEMPLATE GUM_SCALAR gum::InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::entropyYgivenZ ( )

Definition at line 205 of file informationTheory_tpl.h.

                                                                               {
    if (Z_.empty()) GUM_ERROR(ArgumentError, "Z has not been specified.")
    return -pYZ_.expectedValue([this](const gum::Instantiation& i) -> GUM_SCALAR {
      // f(y,z)=log (p(y,z)/p(z))
      const auto& pyz = pYZ_[i];
      if (pyz == GUM_SCALAR(0.0)) return GUM_SCALAR(0.0);
 
      const auto& pz = pZ_[i];
      if (pz == GUM_SCALAR(0.0)) return GUM_SCALAR(0.0);
 
      return GUM_LOG2_OR_0(pyz / pz);
    });
  }

References GUM_ERROR, GUM_LOG2_OR_0, pYZ_, pZ_, and Z_.

◆ makeInference_()

template<template< typename > class INFERENCE_ENGINE, typename GUM_SCALAR>

INFORMATION_THEORY_TEMPLATE void gum::InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::makeInference_ ( )

protected

Definition at line 107 of file informationTheory_tpl.h.

                                                                         {
    vX_.clear();
    for (const auto x: X_)
      vX_.insert(&engine_.model().variable(x));
 
    vY_.clear();
    for (const auto y: Y_)
      vY_.insert(&engine_.model().variable(y));
 
    vZ_.clear();
    for (const auto z: Z_)
      vZ_.insert(&engine_.model().variable(z));
 
    const NodeSet joint_vars = X_ + Y_ + Z_;
    if (!engine_.isJointTarget(joint_vars)) {
      // we check if it is not an implicit target : containng a node and some of its parent (could
      // be better)
      bool implicit_target = false;
      for (const auto node: joint_vars)
        if (engine_.model().family(node).isSupersetOrEqual(joint_vars)) {
          implicit_target = true;
          break;
        }
      if (!implicit_target) {
        engine_.eraseAllJointTargets();
        engine_.addJointTarget(joint_vars);
      }
    }
    engine_.makeInference();
 
    if (!Z_.empty()) {
      pXYZ_ = engine_.jointPosterior(joint_vars);
      pXZ_  = pXYZ_.sumIn(vX_ + vZ_);
      pYZ_  = pXYZ_.sumIn(vY_ + vZ_);
      pZ_   = pXZ_.sumIn(vZ_);
      pXY_  = pXYZ_.sumIn(vX_ + vY_);
    } else {
      pXY_ = engine_.jointPosterior(joint_vars);
    }
    pX_ = pXY_.sumIn(vX_);
    pY_ = pXY_.sumIn(vY_);
  }

References engine_, pX_, pXY_, pXYZ_, pXZ_, pY_, pYZ_, pZ_, vX_, vY_, vZ_, X_, Y_, and Z_.

Referenced by InformationTheory().

Here is the caller graph for this function:

◆ mutualInformationXY()

template<template< typename > class INFERENCE_ENGINE, typename GUM_SCALAR>

INFORMATION_THEORY_TEMPLATE GUM_SCALAR gum::InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::mutualInformationXY ( )

Definition at line 220 of file informationTheory_tpl.h.

                                                                                    {
    return pXY_.expectedValue([this](const gum::Instantiation& i) -> GUM_SCALAR {
      // f(x,y)=log (p(x,y)/p(x)p(y))
      const auto& pxy = pXY_[i];
      if (pxy == GUM_SCALAR(0.0)) return GUM_SCALAR(0.0);
 
      const auto& pxpy = pY_[i] * pX_[i];
      if (pxpy == GUM_SCALAR(0.0)) return GUM_SCALAR(0.0);
 
      return GUM_LOG2_OR_0(pxy / pxpy);
    });
  }

References GUM_LOG2_OR_0, pX_, pXY_, and pY_.

◆ mutualInformationXYgivenZ()

template<template< typename > class INFERENCE_ENGINE, typename GUM_SCALAR>

INFORMATION_THEORY_TEMPLATE GUM_SCALAR gum::InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::mutualInformationXYgivenZ ( )

Definition at line 272 of file informationTheory_tpl.h.

                                                                                          {
    if (Z_.empty()) GUM_ERROR(ArgumentError, "Z has not been specified.")
    return pXYZ_.expectedValue([this](const gum::Instantiation& i) -> GUM_SCALAR {
      // f(x,y)=log (p(x,y)/p(x)p(y))
      const auto& pzpxyz = pXYZ_[i] * pZ_[i];
      if (pzpxyz == GUM_SCALAR(0.0)) return GUM_SCALAR(0.0);
 
      const auto& pxzpyz = pXZ_[i] * pYZ_[i];
      if (pxzpyz == GUM_SCALAR(0.0)) return GUM_SCALAR(0.0);
 
      return GUM_LOG2_OR_0(pzpxyz / pxzpyz);
    });
  }

References GUM_ERROR, GUM_LOG2_OR_0, pXYZ_, pXZ_, pYZ_, pZ_, and Z_.

◆ variationOfInformationXY()

template<template< typename > class INFERENCE_ENGINE, typename GUM_SCALAR>

INFORMATION_THEORY_TEMPLATE GUM_SCALAR gum::InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::variationOfInformationXY ( )

Definition at line 234 of file informationTheory_tpl.h.

                                                                                         {
    return -pXY_.expectedValue([this](const gum::Instantiation& i) -> GUM_SCALAR {
      // f(x,y)= -log(p(x)*p(y))
      return GUM_LOG2_OR_0(pY_[i] * pX_[i]);
    });
  }

References GUM_LOG2_OR_0, pX_, pXY_, and pY_.

Member Data Documentation

◆ engine_

template<template< typename > class INFERENCE_ENGINE, typename GUM_SCALAR>

INFERENCE_ENGINE< GUM_SCALAR >& gum::InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::engine_

protected

Definition at line 116 of file informationTheory.h.

Referenced by InformationTheory(), and makeInference_().

◆ pX_

template<template< typename > class INFERENCE_ENGINE, typename GUM_SCALAR>

Tensor< GUM_SCALAR > gum::InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::pX_

protected

Definition at line 130 of file informationTheory.h.

Referenced by entropyX(), entropyYgivenX(), makeInference_(), mutualInformationXY(), and variationOfInformationXY().

◆ pXY_

template<template< typename > class INFERENCE_ENGINE, typename GUM_SCALAR>

Tensor< GUM_SCALAR > gum::InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::pXY_

protected

Definition at line 127 of file informationTheory.h.

Referenced by entropyXgivenY(), entropyXY(), entropyYgivenX(), makeInference_(), mutualInformationXY(), and variationOfInformationXY().

◆ pXYZ_

template<template< typename > class INFERENCE_ENGINE, typename GUM_SCALAR>

Tensor< GUM_SCALAR > gum::InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::pXYZ_

protected

Definition at line 126 of file informationTheory.h.

Referenced by entropyXgivenYZ(), entropyXYgivenZ(), makeInference_(), and mutualInformationXYgivenZ().

◆ pXZ_

template<template< typename > class INFERENCE_ENGINE, typename GUM_SCALAR>

Tensor< GUM_SCALAR > gum::InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::pXZ_

protected

Definition at line 128 of file informationTheory.h.

Referenced by entropyXgivenZ(), makeInference_(), and mutualInformationXYgivenZ().

◆ pY_

template<template< typename > class INFERENCE_ENGINE, typename GUM_SCALAR>

Tensor< GUM_SCALAR > gum::InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::pY_

protected

Definition at line 131 of file informationTheory.h.

Referenced by entropyXgivenY(), entropyY(), makeInference_(), mutualInformationXY(), and variationOfInformationXY().

◆ pYZ_

template<template< typename > class INFERENCE_ENGINE, typename GUM_SCALAR>

Tensor< GUM_SCALAR > gum::InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::pYZ_

protected

Definition at line 129 of file informationTheory.h.

Referenced by entropyXgivenYZ(), entropyYgivenZ(), makeInference_(), and mutualInformationXYgivenZ().

◆ pZ_

template<template< typename > class INFERENCE_ENGINE, typename GUM_SCALAR>

Tensor< GUM_SCALAR > gum::InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::pZ_

protected

Definition at line 132 of file informationTheory.h.

Referenced by entropyXgivenZ(), entropyXYgivenZ(), entropyYgivenZ(), makeInference_(), and mutualInformationXYgivenZ().

◆ vX_

template<template< typename > class INFERENCE_ENGINE, typename GUM_SCALAR>

VariableSet gum::InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::vX_

protected

Definition at line 122 of file informationTheory.h.

Referenced by makeInference_().

◆ vY_

template<template< typename > class INFERENCE_ENGINE, typename GUM_SCALAR>

VariableSet gum::InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::vY_

protected

Definition at line 123 of file informationTheory.h.

Referenced by makeInference_().

◆ vZ_

template<template< typename > class INFERENCE_ENGINE, typename GUM_SCALAR>

VariableSet gum::InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::vZ_

protected

Definition at line 124 of file informationTheory.h.

Referenced by makeInference_().

◆ X_

template<template< typename > class INFERENCE_ENGINE, typename GUM_SCALAR>

const NodeSet gum::InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::X_

protected

Definition at line 118 of file informationTheory.h.

Referenced by InformationTheory(), and makeInference_().

◆ Y_

template<template< typename > class INFERENCE_ENGINE, typename GUM_SCALAR>

const NodeSet gum::InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::Y_

protected

Definition at line 119 of file informationTheory.h.

Referenced by InformationTheory(), and makeInference_().

◆ Z_

template<template< typename > class INFERENCE_ENGINE, typename GUM_SCALAR>

const NodeSet gum::InformationTheory< INFERENCE_ENGINE, GUM_SCALAR >::Z_

protected

Definition at line 120 of file informationTheory.h.

Referenced by InformationTheory(), entropyXgivenYZ(), entropyXgivenZ(), entropyXYgivenZ(), entropyYgivenZ(), makeInference_(), and mutualInformationXYgivenZ().

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

agrum/base/graphicalModels/algorithms/informationTheory.h
agrum/base/graphicalModels/algorithms/informationTheory_tpl.h

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ InformationTheory() [1/4]

◆ InformationTheory() [2/4]

◆ InformationTheory() [3/4]

◆ InformationTheory() [4/4]

◆ ~InformationTheory()

Member Function Documentation

◆ entropyX()

◆ entropyXgivenY()

◆ entropyXgivenYZ()

◆ entropyXgivenZ()

◆ entropyXY()

◆ entropyXYgivenZ()

◆ entropyY()

◆ entropyYgivenX()

◆ entropyYgivenZ()

◆ makeInference_()

◆ mutualInformationXY()

◆ mutualInformationXYgivenZ()

◆ variationOfInformationXY()

Member Data Documentation

◆ engine_

◆ pX_

◆ pXY_

◆ pXYZ_

◆ pXZ_

◆ pY_

◆ pYZ_

◆ pZ_

◆ vX_

◆ vY_

◆ vZ_

◆ X_

◆ Y_

◆ Z_