Example: random_examples

MRPT includes a C++ platform-independent implementation of the MT19937 algorithm for generating high-quality pseudo-random numbers. The following example demonstrates:

• The usage of random number generators in MRPT. See mrpt::random for the detailed documentation of C++ classes and methods.

• The class mrpt::math::CHistogram.

• The usage of MATLAB-like plots.

C++ example source code:

/* +------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)            |
   |                          https://www.mrpt.org/                         |
   |                                                                        |
   | Copyright (c) 2005-2024, Individual contributors, see AUTHORS file     |
   | See: https://www.mrpt.org/Authors - All rights reserved.               |
   | Released under BSD License. See: https://www.mrpt.org/License          |
   +------------------------------------------------------------------------+ */

#include <mrpt/gui/CDisplayWindowPlots.h>
#include <mrpt/math/distributions.h>
#include <mrpt/random.h>

#include <iostream>

using namespace mrpt;
using namespace mrpt::gui;
using namespace mrpt::math;
using namespace mrpt::random;
using namespace mrpt::system;
using namespace std;

// not run by default. Uncomment corresponding line in the main function.
void TestHist()
{
  CHistogram hist(0.0, 100.0, 10u);
  hist.add(86);
  hist.add(7);
  hist.add(45);

  cout << "Histogram test:" << endl;
  cout << "Should be 1: " << hist.getBinCount(0) << endl;     // Result: "1"
  cout << "Should be 0.33: " << hist.getBinRatio(0) << endl;  // Result: "0.33"
}

// ------------------------------------------------------
//              TestRandomGenerators
// ------------------------------------------------------
void TestRandomGenerators()
{
  vector<double> x, y;

  getRandomGenerator().randomize();

  // Uniform numbers integers:
  CDisplayWindowPlots win1("Unif(0,5) (integers)");
  win1.setPos(10, 10);
  win1.resize(400, 400);
  {
    // CVectorDouble v1(100000);
    std::vector<size_t> v1(100000);
    getRandomGenerator().drawUniformVector(v1, 0, 5.999);

    CHistogram hist(-2, 15, 100);
    hist.add(v1);
    hist.getHistogramNormalized(x, y);

    win1.plot(x, y, "b");

    win1.axis_fit();
  }

  // Normalized Gauss:
  CDisplayWindowPlots win2("N(mean=0,std=1)");
  win2.setPos(420, 10);
  win2.resize(400, 400);
  {
    CVectorDouble v1(100000);
    getRandomGenerator().drawGaussian1DVector(v1, 0, 1);

    CHistogram hist(-5, 5, 100);
    hist.add(v1);
    hist.getHistogramNormalized(x, y);

    win2.plot(x, y, "b");

    CVectorDouble y_real(y.size());
    for (CVectorDouble::Index k = 0; k < y_real.size(); k++)
      y_real[k] = mrpt::math::normalPDF(x[k], 0, 1);
    win2.plot(x, y_real, "k-", "real");

    win2.axis_fit();
  }

  // Example Gauss:
  CDisplayWindowPlots win3("N(mean=3,std=2)");
  win3.setPos(10, 430);
  win3.resize(400, 400);
  {
    CVectorDouble v1(100000);
    getRandomGenerator().drawGaussian1DVector(v1, 3, 2);

    CHistogram hist(-5, 15, 100);
    hist.add(v1);
    hist.getHistogramNormalized(x, y);

    win3.plot(x, y, "b");

    CVectorDouble y_real(y.size());
    for (CVectorDouble::Index k = 0; k < y_real.size(); k++)
      y_real[k] = mrpt::math::normalPDF(x[k], 3, 2);
    win3.plot(x, y_real, "k-", "real");

    win3.axis_fit();
  }

  // Example multi-variate Gauss:
  CDisplayWindowPlots win4("N(mean=[3 4],var=[4 -2;-2 4])");
  win4.setPos(420, 430);
  win4.resize(400, 400);
  {
    vector<CVectorDouble> v1;
    CVectorDouble Mean(2);
    Mean[0] = 3;
    Mean[1] = 2;

    CMatrixDouble22 cov;
    cov.fromMatlabStringFormat("[7.5 -7;-7 8]");

    getRandomGenerator().drawGaussianMultivariateMany(v1, 10000, cov, &Mean);

#if 0
        CVectorDouble m;
        CMatrixDouble c;
        mrpt::math::meanAndCov(v1,m,c);
        cout << "Mean: " << m << endl;
        cout << "Std: " << endl << c << endl;
#endif

    // pass to (x,y) vectors:
    CVectorDouble vx(v1.size()), vy(v1.size());
    for (size_t i = 0; i < v1.size(); i++)
    {
      vx[i] = v1[i][0];
      vy[i] = v1[i][1];
    }

    win4.plot(vx, vy, "b.3");

    win4.plotEllipse(Mean[0], Mean[1], cov, 3.0, "k-2", "99% ellipse", true);

    win4.axis_fit();
  }

  win4.waitForKey();
}

// ------------------------------------------------------
//                      MAIN
// ------------------------------------------------------
int main()
{
  try
  {
    // TestHist();
    TestRandomGenerators();

    return 0;
  }
  catch (const std::exception& e)
  {
    std::cerr << "MRPT error: " << mrpt::exception_to_str(e) << std::endl;
    return -1;
  }
}