test5.cpp

Go to the documentation of this file.

#include "indii/ml/aux/GaussianPdf.hpp"
#include "indii/ml/aux/DiracPdf.hpp"
#include "indii/ml/aux/UniformPdf.hpp"
#include "indii/ml/aux/DensityTreePdf.hpp"
#include "indii/ml/aux/GaussianMixturePdf.hpp"
#include "indii/ml/aux/DiracMixturePdf.hpp"
#include "indii/ml/aux/DensityTreeMixturePdf.hpp"

#include "boost/archive/binary_iarchive.hpp"
#include "boost/archive/binary_oarchive.hpp"

#include <fstream>
#include <iostream>
#include <ios>

namespace aux = indii::ml::aux;

/**
 * @file test5.cpp
 *
 * Test of serialization, input and output, for all pdfs. A random pdf
 * is constructed for each type, serialized and output to a file. A
 * new pdf is constructed from the serialization in the file and
 * compared to the original for equality.
 *
 * Results are as follows:
 *
 * @include test5.out
 */

/**
 * Dimensionality of the distributions.
 */
unsigned int N = 4;

/**
 * Number of components for Gaussian mixture test.
 */
unsigned int GAUSSIAN_MIXTURE_COMPONENTS = 12;

/**
 * Number of components for Dirac mixture test.
 */
unsigned int DIRAC_MIXTURE_COMPONENTS = 1000;

/**
 * Number of components for density tree mixture test.
 */
unsigned int TREE_MIXTURE_COMPONENTS = 12;

/**
 * Create random Dirac distribution.
 *
 * @param M Dimensionality of the Dirac.
 * @param minMean Minimum value of any component of the mean.
 * @param maxMean Maximum value of any component of the mean.
 *
 * Dirac with given dimensionality, with mean randomly generated
 * uniformly from within the given bounds.
 */
aux::DiracPdf createRandomDirac(const unsigned int M,
    const double minMean = -5.0, const double maxMean = 5.0) {
  aux::DiracPdf dirac(M);
  unsigned int i;

  /* mean */
  for (i = 0; i < M; i++) {
    dirac(i) = aux::Random::uniform(minMean, maxMean);
  }

  return dirac;
}

/**
 * Create random Gaussian distribution.
 *
 * @param M Dimensionality of the Gaussian.
 * @param minMean Minimum value of any component of the mean.
 * @param maxMean Maximum value of any component of the mean.
 * @param minCov Minimum value of any component of the covariance.
 * @param maxCov Maximum value of any component of the covariance.
 *
 * @return Gaussian with given dimensionality, with mean and
 * covariance randomly generated uniformly from within the given
 * bounds.
 */
aux::GaussianPdf createRandomGaussian(const unsigned int M,
    const double minMean = -5.0, const double maxMean = 5.0,
    const double minCov = 0.0, const double maxCov = 5.0) {
  aux::vector mu(M);
  aux::symmetric_matrix sigma(M);

  unsigned int i, j;

  /* mean */
  for (i = 0; i < M; i++) {
    mu(i) = aux::Random::uniform(minMean, maxMean);
  }

  /* covariance */
  for (i = 0; i < M; i++) {
    for (j = 0; j <= i; j++) {
      sigma(i,j) = aux::Random::uniform(sqrt(minCov) / M, sqrt(maxCov) / M);
    }
  }
  sigma = prod(sigma, trans(sigma)); // ensures cholesky decomposable

  return aux::GaussianPdf(mu, sigma);
}

/**
 * Create random uniform distribution.
 *
 * @param M Dimensionality of the distribution.
 * @param minBound Minimum value of any component of a bound.
 * @param maxBound Maximum value of any component of a bound.
 *
 * @return Uniform distribution with given dimensionality, with lower and
 * upper bound randomly generated uniformly from within the given bounds.
 */
aux::UniformPdf createRandomUniform(const unsigned int M,
    const double minBound = -5.0, const double maxBound = 5.0) {
  aux::vector lower(M), upper(M);
  double a, b;
  unsigned int i;
  
  for (i = 0; i < M; i++) {
    a = aux::Random::uniform(minBound, maxBound);
    b = aux::Random::uniform(minBound, maxBound);
    
    if (a > b) {
      upper(i) = a;
      lower(i) = b;
    } else {
      upper(i) = b;
      lower(i) = a;
    }
  }
  
  return aux::UniformPdf(lower, upper);
}

/**
 * Determines whether a vector is the zero vector.
 */
bool isZero(const aux::vector& x) {
  unsigned int i;
  for (i = 0; i < x.size(); i++) {
    if (x(i) != 0.0) {
      return false;
    }
  }
  return true;
}

/**
 * Determine whether a matrix is the zero matrix.
 */
bool isZero(const aux::matrix& A) {
  unsigned int i, j;
  for (i = 0; i < A.size1(); i++) {
    for (j = 0; j < A.size2(); j++) {
      if (A(i,j) != 0.0) {
  return false;
      }
    }
  }
  return true;
}

/**
 * Test of GaussianPdf.
 */
bool testGaussianPdf() {
  bool passed;
  aux::vector mu(N);
  aux::symmetric_matrix sigma(N);

  aux::GaussianPdf gaussianIn;
  const aux::GaussianPdf gaussianOut(createRandomGaussian(N));
  {
    std::ofstream outFile("data/GaussianPdf.obj", std::ios::binary);
    boost::archive::binary_oarchive outArchive(outFile);
    outArchive << gaussianOut;
  }
  {
    std::ifstream inFile("data/GaussianPdf.obj", std::ios::binary);
    boost::archive::binary_iarchive inArchive(inFile);
    inArchive >> gaussianIn;
  }
  
  passed = isZero(gaussianOut.getExpectation() - gaussianIn.getExpectation());
  passed &= isZero(gaussianOut.getCovariance() - gaussianIn.getCovariance());

  return passed;
}

/**
 * Test of DiracPdf.
 */
bool testDiracPdf() {
  bool passed;

  aux::DiracPdf diracIn;
  const aux::DiracPdf diracOut(createRandomDirac(N));
  {
    std::ofstream outFile("data/DiracPdf.obj", std::ios::binary);
    boost::archive::binary_oarchive outArchive(outFile);
    outArchive << diracOut;
  }
  {
    std::ifstream inFile("data/DiracPdf.obj", std::ios::binary);
    boost::archive::binary_iarchive inArchive(inFile);
    inArchive >> diracIn;
  }
  
  passed = isZero(diracOut.getExpectation() - diracIn.getExpectation());

  return passed;
}

/**
 * Test of UniformPdf.
 */
bool testUniformPdf() {
  bool passed;

  aux::UniformPdf uniformIn;
  aux::UniformPdf uniformOut(createRandomUniform(N));
  {
    std::ofstream outFile("data/UniformPdf.obj", std::ios::binary);
    boost::archive::binary_oarchive outArchive(outFile);
    const aux::UniformPdf tmp(uniformOut);
    outArchive << tmp;
  }
  {
    std::ifstream inFile("data/UniformPdf.obj", std::ios::binary);
    boost::archive::binary_iarchive inArchive(inFile);
    inArchive >> uniformIn;
  }
  
  passed = isZero(uniformOut.getExpectation() - uniformIn.getExpectation());
  passed &= isZero(uniformOut.getCovariance() - uniformIn.getCovariance());

  return passed;
}

/**
 * Test of DensityTreePdf.
 */
bool testDensityTreePdf() {
  bool passed;
  unsigned int i;

  aux::DensityTreePdf treeIn;
  aux::DiracMixturePdf samples(N);
  for (i = 0; i < DIRAC_MIXTURE_COMPONENTS; i++) {
    samples.addComponent(createRandomDirac(N),
        aux::Random::uniform(0.0,1.0));
  }
  aux::DensityTreePdf treeOut(samples);

  {
    std::ofstream outFile("data/DensityTreePdf.obj", std::ios::binary);
    boost::archive::binary_oarchive outArchive(outFile);
    const aux::DensityTreePdf tmp(treeOut);
    outArchive << tmp;
  }
  {
    std::ifstream inFile("data/DensityTreePdf.obj", std::ios::binary);
    boost::archive::binary_iarchive inArchive(inFile);
    inArchive >> treeIn;
  }
  
  passed = isZero(treeOut.getExpectation() - treeIn.getExpectation());
  passed &= isZero(treeOut.getCovariance() - treeIn.getCovariance());

  return passed;
}

/**
 * Test of GaussianMixturePdf.
 */
bool testGaussianMixturePdf() {
  bool passed;
  unsigned int i;
  aux::vector mu(N);
  aux::symmetric_matrix sigma(N);
  aux::GaussianMixturePdf::weighted_component_vector::const_iterator iter1,
      iter2, end1, end2;

  aux::GaussianMixturePdf gaussianMixIn;
  aux::GaussianMixturePdf gaussianMixOut(N);
  for (i = 0; i < GAUSSIAN_MIXTURE_COMPONENTS; i++) {
    gaussianMixOut.addComponent(createRandomGaussian(N),
        aux::Random::uniform(0.0,1.0));
  }

  {
    std::ofstream outFile("data/GaussianMixturePdf.obj", std::ios::binary);
    boost::archive::binary_oarchive outArchive(outFile);
    const aux::GaussianMixturePdf tmp(gaussianMixOut);
    outArchive << tmp;
  }
  {
    std::ifstream inFile("data/GaussianMixturePdf.obj", std::ios::binary);
    boost::archive::binary_iarchive inArchive(inFile);
    inArchive >> gaussianMixIn;
  }
  
  passed = true;
  iter1 = gaussianMixIn.getComponents().begin();
  end1 = gaussianMixIn.getComponents().end();
  iter2 = gaussianMixOut.getComponents().begin();
  end2 = gaussianMixOut.getComponents().end();
  while (passed && iter1 != end1 && iter2 != end2) {
    passed &= iter1->w == iter2->w;
    passed &= isZero(iter1->x.getExpectation() - iter2->x.getExpectation());
    passed &= isZero(iter2->x.getCovariance() - iter2->x.getCovariance());

    iter1++;
    iter2++;
  }
  passed &= iter1 == end1;
  passed &= iter2 == end2;

  return passed;
}

/**
 * Test of DiracMixturePdf.
 */
bool testDiracMixturePdf() {
  bool passed;
  unsigned int i;
  aux::vector mu(N);
  aux::DiracMixturePdf::weighted_component_vector::const_iterator iter1,
      iter2, end1, end2;

  aux::DiracMixturePdf diracMixIn;
  aux::DiracMixturePdf diracMixOut(N);
  for (i = 0; i < DIRAC_MIXTURE_COMPONENTS; i++) {
    diracMixOut.addComponent(createRandomDirac(N),
        aux::Random::uniform(0.0,1.0));
  }

  {
    std::ofstream outFile("data/DiracMixturePdf.obj", std::ios::binary);
    boost::archive::binary_oarchive outArchive(outFile);
    const aux::DiracMixturePdf tmp(diracMixOut);
    outArchive << tmp;
  }
  {
    std::ifstream inFile("data/DiracMixturePdf.obj", std::ios::binary);
    boost::archive::binary_iarchive inArchive(inFile);
    inArchive >> diracMixIn;
  }
  
  passed = true;
  iter1 = diracMixIn.getComponents().begin();
  end1 = diracMixIn.getComponents().end();
  iter2 = diracMixOut.getComponents().begin();
  end2 = diracMixOut.getComponents().end();
  while (passed && iter1 != end1 && iter2 != end2) {
    passed &= iter1->w == iter2->w;
    passed &= isZero(iter1->x.getExpectation() - iter2->x.getExpectation());

    iter1++;
    iter2++;
  }
  passed &= iter1 == end1;
  passed &= iter2 == end2;

  return passed;
}

/**
 * Test of DensityTreeMixturePdf.
 */
bool testDensityTreeMixturePdf() {
  bool passed;
  unsigned int i, j;
  aux::DensityTreeMixturePdf::weighted_component_iterator iter1,
      iter2, end1, end2; 
  aux::DensityTreeMixturePdf treeMixIn;
  aux::DensityTreeMixturePdf treeMixOut(N);
  
  for (i = 0; i < TREE_MIXTURE_COMPONENTS; i++) {
    aux::DiracMixturePdf samples(N);
    for (j = 0; j < DIRAC_MIXTURE_COMPONENTS; j++) {
      samples.addComponent(createRandomDirac(N),
          aux::Random::uniform(0.0,1.0));
    }
    treeMixOut.addComponent(aux::DensityTreePdf(samples),
        aux::Random::uniform(0.0,1.0));
  }

  {
    std::ofstream outFile("data/DensityTreeMixturePdf.obj", std::ios::binary);
    boost::archive::binary_oarchive outArchive(outFile);
    const aux::DensityTreeMixturePdf tmp(treeMixOut);
    outArchive << tmp;
  }
  {
    std::ifstream inFile("data/DensityTreeMixturePdf.obj", std::ios::binary);
    boost::archive::binary_iarchive inArchive(inFile);
    inArchive >> treeMixIn;
  }
  
  passed = true;
  iter1 = treeMixIn.getComponents().begin();
  end1 = treeMixIn.getComponents().end();
  iter2 = treeMixOut.getComponents().begin();
  end2 = treeMixOut.getComponents().end();
  while (passed && iter1 != end1 && iter2 != end2) {
    passed &= iter1->w == iter2->w;
    passed &= isZero(iter1->x.getExpectation() - iter2->x.getExpectation());

    iter1++;
    iter2++;
  }
  passed &= iter1 == end1;
  passed &= iter2 == end2;

  return passed;
}

/**
 * Run tests.
 */
int main(int argc, const char* argv[]) {

  std::cout << "GaussianPdf ";
  if (testGaussianPdf()) {
    std::cout << "passed";
  } else {
    std::cout << "failed";
  }
  std::cout << std::endl;

  std::cout << "DiracPdf ";
  if (testDiracPdf()) {
    std::cout << "passed";
  } else {
    std::cout << "failed";
  }
  std::cout << std::endl;

  std::cout << "UniformPdf ";
  if (testUniformPdf()) {
    std::cout << "passed";
  } else {
    std::cout << "failed";
  }
  std::cout << std::endl;

  std::cout << "DensityTreePdf ";
  if (testDensityTreePdf()) {
    std::cout << "passed";
  } else {
    std::cout << "failed";
  }
  std::cout << std::endl;

  std::cout << "GaussianMixturePdf ";
  if (testGaussianMixturePdf()) {
    std::cout << "passed";
  } else {
    std::cout << "failed";
  }
  std::cout << std::endl;

  std::cout << "DiracMixturePdf ";
  if (testDiracMixturePdf()) {
    std::cout << "passed";
  } else {
    std::cout << "failed";
  }
  std::cout << std::endl;

  std::cout << "DensityTreeMixturePdf ";
  if (testDensityTreeMixturePdf()) {
    std::cout << "passed";
  } else {
    std::cout << "failed";
  }
  std::cout << std::endl;

  return 0;
}

---