Main MRPT website > C++ reference for MRPT 1.9.9
math.cpp
Go to the documentation of this file.
1 /* +------------------------------------------------------------------------+
2  | Mobile Robot Programming Toolkit (MRPT) |
3  | http://www.mrpt.org/ |
4  | |
5  | Copyright (c) 2005-2018, Individual contributors, see AUTHORS file |
6  | See: http://www.mrpt.org/Authors - All rights reserved. |
7  | Released under BSD License. See details in http://www.mrpt.org/License |
8  +------------------------------------------------------------------------+ */
9 
10 #include "math-precomp.h" // Precompiled headers
11 
12 #include <mrpt/math/utils.h>
13 #include <mrpt/math/wrap2pi.h>
14 #include <mrpt/math/interp_fit.hpp>
15 #include <mrpt/math/data_utils.h>
17 
19 #include <mrpt/math/CMatrixD.h>
20 #include <mrpt/math/ops_matrices.h>
21 #include <cmath> // erf(), ...
22 #include <algorithm>
23 #include <iostream>
24 
25 using namespace mrpt;
26 using namespace mrpt::math;
27 using namespace std;
29 
30 /*---------------------------------------------------------------
31  normalPDF
32  ---------------------------------------------------------------*/
33 double math::normalPDF(double x, double mu, double std)
34 {
35  return ::exp(-0.5 * square((x - mu) / std)) /
36  (std * 2.506628274631000502415765284811);
37 }
38 
39 /*---------------------------------------------------------------
40  chi2inv
41  ---------------------------------------------------------------*/
42 double math::chi2inv(double P, unsigned int dim)
43 {
44  ASSERT_(P >= 0 && P < 1);
45  if (P == 0)
46  return 0;
47  else
48  return dim * pow(1.0 - 2.0 / (9 * dim) +
49  sqrt(2.0 / (9 * dim)) * normalQuantile(P),
50  3);
51 }
52 
53 /*---------------------------------------------------------------
54  factorial64
55  ---------------------------------------------------------------*/
57 {
58  uint64_t ret = 1;
59 
60  for (unsigned int i = 2; i <= n; i++) ret *= i;
61 
62  return ret;
63 }
64 
65 /*---------------------------------------------------------------
66  factorial
67  ---------------------------------------------------------------*/
68 double math::factorial(unsigned int n)
69 {
70  double retLog = 0;
71 
72  for (unsigned int i = 2; i <= n; i++) retLog += ::log((double)n);
73 
74  return ::exp(retLog);
75 }
76 
77 /*---------------------------------------------------------------
78  normalQuantile
79  ---------------------------------------------------------------*/
80 double math::normalQuantile(double p)
81 {
82  double q, t, u;
83 
84  static const double a[6] = {-3.969683028665376e+01, 2.209460984245205e+02,
85  -2.759285104469687e+02, 1.383577518672690e+02,
86  -3.066479806614716e+01, 2.506628277459239e+00};
87  static const double b[5] = {-5.447609879822406e+01, 1.615858368580409e+02,
88  -1.556989798598866e+02, 6.680131188771972e+01,
89  -1.328068155288572e+01};
90  static const double c[6] = {-7.784894002430293e-03, -3.223964580411365e-01,
91  -2.400758277161838e+00, -2.549732539343734e+00,
92  4.374664141464968e+00, 2.938163982698783e+00};
93  static const double d[4] = {7.784695709041462e-03, 3.224671290700398e-01,
94  2.445134137142996e+00, 3.754408661907416e+00};
95 
96  ASSERT_(!std::isnan(p));
98 
99  q = min(p, 1 - p);
100 
101  if (q > 0.02425)
102  {
103  /* Rational approximation for central region. */
104  u = q - 0.5;
105  t = u * u;
106  u = u * (((((a[0] * t + a[1]) * t + a[2]) * t + a[3]) * t + a[4]) * t +
107  a[5]) /
108  (((((b[0] * t + b[1]) * t + b[2]) * t + b[3]) * t + b[4]) * t + 1);
109  }
110  else
111  {
112  /* Rational approximation for tail region. */
113  t = sqrt(-2 * ::log(q));
114  u = (((((c[0] * t + c[1]) * t + c[2]) * t + c[3]) * t + c[4]) * t +
115  c[5]) /
116  ((((d[0] * t + d[1]) * t + d[2]) * t + d[3]) * t + 1);
117  }
118 
119  /* The relative error of the approximation has absolute value less
120  than 1.15e-9. One iteration of Halley's rational method (third
121  order) gives full machine precision... */
122  t = normalCDF(u) - q; /* error */
123  t = t * 2.506628274631000502415765284811 *
124  ::exp(u * u / 2); /* f(u)/df(u) */
125  u = u - t / (1 + u * t / 2); /* Halley's method */
126 
127  return (p > 0.5 ? -u : u);
128 }
129 
130 /*---------------------------------------------------------------
131  normalCDF
132  ---------------------------------------------------------------*/
133 double math::normalCDF(double u)
134 {
135  static const double a[5] = {1.161110663653770e-002, 3.951404679838207e-001,
136  2.846603853776254e+001, 1.887426188426510e+002,
137  3.209377589138469e+003};
138  static const double b[5] = {1.767766952966369e-001, 8.344316438579620e+000,
139  1.725514762600375e+002, 1.813893686502485e+003,
140  8.044716608901563e+003};
141  static const double c[9] = {
142  2.15311535474403846e-8, 5.64188496988670089e-1, 8.88314979438837594e00,
143  6.61191906371416295e01, 2.98635138197400131e02, 8.81952221241769090e02,
144  1.71204761263407058e03, 2.05107837782607147e03, 1.23033935479799725E03};
145  static const double d[9] = {
146  1.00000000000000000e00, 1.57449261107098347e01, 1.17693950891312499e02,
147  5.37181101862009858e02, 1.62138957456669019e03, 3.29079923573345963e03,
148  4.36261909014324716e03, 3.43936767414372164e03, 1.23033935480374942e03};
149  static const double p[6] = {1.63153871373020978e-2, 3.05326634961232344e-1,
150  3.60344899949804439e-1, 1.25781726111229246e-1,
151  1.60837851487422766e-2, 6.58749161529837803e-4};
152  static const double q[6] = {1.00000000000000000e00, 2.56852019228982242e00,
153  1.87295284992346047e00, 5.27905102951428412e-1,
154  6.05183413124413191e-2, 2.33520497626869185e-3};
155  double y, z;
156 
157  ASSERT_(!std::isnan(u));
158  ASSERT_(std::isfinite(u));
159 
160  y = fabs(u);
161  if (y <= 0.46875 * 1.4142135623730950488016887242097)
162  {
163  /* evaluate erf() for |u| <= sqrt(2)*0.46875 */
164  z = y * y;
165  y = u * ((((a[0] * z + a[1]) * z + a[2]) * z + a[3]) * z + a[4]) /
166  ((((b[0] * z + b[1]) * z + b[2]) * z + b[3]) * z + b[4]);
167  return 0.5 + y;
168  }
169 
170  z = ::exp(-y * y / 2) / 2;
171  if (y <= 4.0)
172  {
173  /* evaluate erfc() for sqrt(2)*0.46875 <= |u| <= sqrt(2)*4.0 */
174  y = y / 1.4142135623730950488016887242097;
175  y = ((((((((c[0] * y + c[1]) * y + c[2]) * y + c[3]) * y + c[4]) * y +
176  c[5]) *
177  y +
178  c[6]) *
179  y +
180  c[7]) *
181  y +
182  c[8])
183 
184  / ((((((((d[0] * y + d[1]) * y + d[2]) * y + d[3]) * y + d[4]) * y +
185  d[5]) *
186  y +
187  d[6]) *
188  y +
189  d[7]) *
190  y +
191  d[8]);
192 
193  y = z * y;
194  }
195  else
196  {
197  /* evaluate erfc() for |u| > sqrt(2)*4.0 */
198  z = z * 1.4142135623730950488016887242097 / y;
199  y = 2 / (y * y);
200  y = y * (((((p[0] * y + p[1]) * y + p[2]) * y + p[3]) * y + p[4]) * y +
201  p[5]) /
202  (((((q[0] * y + q[1]) * y + q[2]) * y + q[3]) * y + q[4]) * y +
203  q[5]);
204  y = z * (0.564189583547756286948 - y);
205  }
206  return (u < 0.0 ? y : 1 - y);
207 }
208 
209 // Loads a vector from a text file:
210 bool math::loadVector(std::istream& f, ::std::vector<int>& d)
211 {
212  MRPT_START
213 
214  std::string str;
215  if (!std::getline(f, str)) return false;
216 
217  const char* s = str.c_str();
218 
219  char *nextTok, *context;
220  const char* delim = " \t";
221 
222  d.clear();
223  nextTok = mrpt::system::strtok((char*)s, delim, &context);
224  while (nextTok != nullptr)
225  {
226  d.push_back(atoi(nextTok));
227  nextTok = mrpt::system::strtok(nullptr, delim, &context);
228  };
229 
230  return true;
231  MRPT_END
232 }
233 
234 bool math::loadVector(std::istream& f, ::std::vector<double>& d)
235 {
236  MRPT_START
237 
238  std::string str;
239  if (!std::getline(f, str)) return false;
240 
241  const char* s = str.c_str();
242 
243  char *nextTok, *context;
244  const char* delim = " \t";
245 
246  d.clear();
247  nextTok = mrpt::system::strtok((char*)s, delim, &context);
248  while (nextTok != nullptr)
249  {
250  d.push_back(atof(nextTok));
251  nextTok = mrpt::system::strtok(nullptr, delim, &context);
252  };
253 
254  return true;
255  MRPT_END
256 }
257 
258 // See declaration for the documentation
260  const CVectorDouble& logWeights, const CVectorDouble& logLikelihoods)
261 {
262  MRPT_START
263 
264  // Explained in:
265  // http://www.mrpt.org/Averaging_Log-Likelihood_Values:Numerical_Stability
266  ASSERT_(logWeights.size() == logLikelihoods.size());
267 
268  if (!logWeights.size())
269  THROW_EXCEPTION("ERROR: logWeights vector is empty!");
270 
272  double lw_max = math::maximum(logWeights);
273  double ll_max = math::maximum(logLikelihoods);
274  double SUM1 = 0, SUM2 = 0, tmpVal;
275 
276  for (itLW = logWeights.begin(), itLL = logLikelihoods.begin();
277  itLW != logWeights.end(); itLW++, itLL++)
278  {
279  tmpVal = *itLW - lw_max;
280  SUM1 += std::exp(tmpVal);
281  SUM2 += std::exp(tmpVal + *itLL - ll_max);
282  }
283 
284  double res = -std::log(SUM1) + std::log(SUM2) + ll_max;
286  return res;
287  MRPT_END
288 }
289 
290 // Unweighted version:
291 double math::averageLogLikelihood(const CVectorDouble& logLikelihoods)
292 {
293  MRPT_START
294 
295  // Explained in:
296  // http://www.mrpt.org/Averaging_Log-Likelihood_Values:Numerical_Stability
297  size_t N = logLikelihoods.size();
298  if (!N) THROW_EXCEPTION("ERROR: logLikelihoods vector is empty!");
299 
300  double ll_max = math::maximum(logLikelihoods);
301  double SUM1 = 0;
302 
303  for (size_t i = 0; i < N; i++) SUM1 += exp(logLikelihoods[i] - ll_max);
304 
305  double res = log(SUM1) - log(static_cast<double>(N)) + ll_max;
306 
308  return res;
309  MRPT_END
310 }
311 
312 // Wrapped angles average:
313 double math::averageWrap2Pi(const CVectorDouble& angles)
314 {
315  if (angles.empty()) return 0;
316 
317  int W_phi_R = 0, W_phi_L = 0;
318  double phi_R = 0, phi_L = 0;
319 
320  // First: XY
321  // -----------------------------------
322  for (CVectorDouble::Index i = 0; i < angles.size(); i++)
323  {
324  double phi = angles[i];
325  if (abs(phi) > 1.5707963267948966192313216916398)
326  {
327  // LEFT HALF: 0,2pi
328  if (phi < 0) phi = (M_2PI + phi);
329 
330  phi_L += phi;
331  W_phi_L++;
332  }
333  else
334  {
335  // RIGHT HALF: -pi,pi
336  phi_R += phi;
337  W_phi_R++;
338  }
339  }
340 
341  // Next: PHI
342  // -----------------------------------
343  // The mean value from each side:
344  if (W_phi_L) phi_L /= static_cast<double>(W_phi_L); // [0,2pi]
345  if (W_phi_R) phi_R /= static_cast<double>(W_phi_R); // [-pi,pi]
346 
347  // Left side to [-pi,pi] again:
348  if (phi_L > M_PI) phi_L -= M_2PI;
349 
350  // The total mean:
351  return ((phi_L * W_phi_L + phi_R * W_phi_R) / (W_phi_L + W_phi_R));
352 }
353 
355  const CMatrixFloat& cov, const CVectorFloat& mean, const float& stdCount,
356  const string& style, const size_t& nEllipsePoints)
357 {
358  MRPT_START
359  CMatrixD cov2(cov);
360  CVectorDouble mean2(2);
361  mean2[0] = mean[0];
362  mean2[1] = mean[1];
363 
365  cov2, mean2, stdCount, style, nEllipsePoints);
366 
367  MRPT_END
368 }
369 
371  const CMatrixDouble& cov, const CVectorDouble& mean, const float& stdCount,
372  const string& style, const size_t& nEllipsePoints)
373 {
374  MRPT_START
375 
376  ASSERT_(cov.cols() == cov.rows() && cov.cols() == 2);
377  ASSERT_(cov(0, 1) == cov(1, 0));
378  ASSERT_(!((cov(0, 0) == 0) ^ (cov(1, 1) == 0))); // Both or none 0
379  ASSERT_(mean.size() == 2);
380 
381  std::vector<float> X, Y, COS, SIN;
382  std::vector<float>::iterator x, y, Cos, Sin;
383  double ang;
384  CMatrixD eigVal, eigVec, M;
385  string str;
386 
387  X.resize(nEllipsePoints);
388  Y.resize(nEllipsePoints);
389  COS.resize(nEllipsePoints);
390  SIN.resize(nEllipsePoints);
391 
392  // Fill the angles:
393  for (Cos = COS.begin(), Sin = SIN.begin(), ang = 0; Cos != COS.end();
394  ++Cos, ++Sin, ang += (M_2PI / (nEllipsePoints - 1)))
395  {
396  *Cos = (float)cos(ang);
397  *Sin = (float)sin(ang);
398  }
399 
400  cov.eigenVectors(eigVec, eigVal);
401  eigVal = eigVal.array().sqrt().matrix();
402  M = eigVal * eigVec.adjoint();
403 
404  // Compute the points of the ellipsoid:
405  // ----------------------------------------------
406  for (x = X.begin(), y = Y.begin(), Cos = COS.begin(), Sin = SIN.begin();
407  x != X.end(); ++x, ++y, ++Cos, ++Sin)
408  {
409  *x = (float)(mean[0] + stdCount * (*Cos * M(0, 0) + *Sin * M(1, 0)));
410  *y = (float)(mean[1] + stdCount * (*Cos * M(0, 1) + *Sin * M(1, 1)));
411  }
412 
413  // Save the code to plot the ellipsoid:
414  // ----------------------------------------------
415  str += string("plot([ ");
416  for (x = X.begin(); x != X.end(); ++x)
417  {
418  str += format("%.4f", *x);
419  if (x != (X.end() - 1)) str += format(",");
420  }
421  str += string("],[ ");
422  for (y = Y.begin(); y != Y.end(); ++y)
423  {
424  str += format("%.4f", *y);
425  if (y != (Y.end() - 1)) str += format(",");
426  }
427 
428  str += format("],'%s');\n", style.c_str());
429 
430  return str;
432  std::cerr << "The matrix that led to error was: " << std::endl
433  << cov << std::endl;)
434 }
435 
437  const double x, const double x0, const double y0, const double x1,
438  const double y1, bool wrap2pi)
439 {
440  MRPT_START
441  if (x0 == x1)
442  THROW_EXCEPTION_FMT("ERROR: Both x0 and x1 are equal (=%f)", x0);
443 
444  const double Ax = x1 - x0;
445  const double Ay = y1 - y0;
446 
447  double r = y0 + Ay * (x - x0) / Ax;
448  if (!wrap2pi)
449  return r;
450  else
451  return mrpt::math::wrapToPi(r);
452 
453  MRPT_END
454 }
455 
456 /*---------------------------------------------------------------
457  median filter of a vector
458  ---------------------------------------------------------------*/
459 // template<typename VECTOR>
461  const std::vector<double>& inV, std::vector<double>& outV,
462  const int& _winSize, const int& numberOfSigmas)
463 {
464  MRPT_UNUSED_PARAM(numberOfSigmas);
465  ASSERT_((int)inV.size() >= _winSize);
466  ASSERT_(_winSize >= 2); // The minimum window size is 3 elements
467  size_t winSize = _winSize;
468 
469  if (!(winSize % 2)) // We use an odd number of elements for the window size
470  winSize++;
471 
472  size_t sz = inV.size();
473  outV.resize(sz);
474 
475  std::vector<double> aux(winSize);
476  size_t mpoint = winSize / 2;
477  for (size_t k = 0; k < sz; ++k)
478  {
479  aux.clear();
480 
481  size_t idx_to_start =
482  std::max(size_t(0), k - mpoint); // Dealing with the boundaries
483  size_t n_elements =
484  std::min(std::min(winSize, sz + mpoint - k), k + mpoint + 1);
485 
486  aux.resize(n_elements);
487  for (size_t m = idx_to_start, n = 0; m < idx_to_start + n_elements;
488  ++m, ++n)
489  aux[n] = inV[m];
490 
491  std::sort(aux.begin(), aux.end());
492 
493  size_t auxSz = aux.size();
494  size_t auxMPoint = auxSz / 2;
495  outV[k] = (auxSz % 2) ? (aux[auxMPoint])
496  : (0.5 * (aux[auxMPoint - 1] +
497  aux[auxMPoint])); // If the window is
498  // even, take the
499  // mean value of the
500  // middle points
501  } // end-for
502 } // end medianFilter
503 
504 double mrpt::math::chi2CDF(unsigned int degreesOfFreedom, double arg)
505 {
506  return noncentralChi2CDF(degreesOfFreedom, 0.0, arg);
507 }
508 
509 template <class T>
511  T arg, T& lans, T& dans, T& pans, unsigned int& j)
512 {
513  double tol = -50.0;
514  if (lans < tol)
515  {
516  lans = lans + std::log(arg / j);
517  dans = std::exp(lans);
518  }
519  else
520  {
521  dans = dans * arg / j;
522  }
523  pans = pans - dans;
524  j += 2;
525 }
526 
527 std::pair<double, double> mrpt::math::noncentralChi2PDF_CDF(
528  unsigned int degreesOfFreedom, double noncentrality, double arg, double eps)
529 {
530  ASSERTMSG_(
531  noncentrality >= 0.0 && arg >= 0.0 && eps > 0.0,
532  "noncentralChi2PDF_CDF(): parameters must be positive.");
533 
534  if (arg == 0.0 && degreesOfFreedom > 0) return std::make_pair(0.0, 0.0);
535 
536  // Determine initial values
537  double b1 = 0.5 * noncentrality, ao = std::exp(-b1), eps2 = eps / ao,
538  lnrtpi2 = 0.22579135264473, probability, density, lans, dans, pans,
539  sum, am, hold;
540  unsigned int maxit = 500, i, m;
541  if (degreesOfFreedom % 2)
542  {
543  i = 1;
544  lans = -0.5 * (arg + std::log(arg)) - lnrtpi2;
545  dans = std::exp(lans);
546  pans = std::erf(std::sqrt(arg / 2.0));
547  }
548  else
549  {
550  i = 2;
551  lans = -0.5 * arg;
552  dans = std::exp(lans);
553  pans = 1.0 - dans;
554  }
555 
556  // Evaluate first term
557  if (degreesOfFreedom == 0)
558  {
559  m = 1;
560  degreesOfFreedom = 2;
561  am = b1;
562  sum = 1.0 / ao - 1.0 - am;
563  density = am * dans;
564  probability = 1.0 + am * pans;
565  }
566  else
567  {
568  m = 0;
569  degreesOfFreedom = degreesOfFreedom - 1;
570  am = 1.0;
571  sum = 1.0 / ao - 1.0;
572  while (i < degreesOfFreedom)
573  noncentralChi2OneIteration(arg, lans, dans, pans, i);
574  degreesOfFreedom = degreesOfFreedom + 1;
575  density = dans;
576  probability = pans;
577  }
578  // Evaluate successive terms of the expansion
579  for (++m; m < maxit; ++m)
580  {
581  am = b1 * am / m;
582  noncentralChi2OneIteration(arg, lans, dans, pans, degreesOfFreedom);
583  sum = sum - am;
584  density = density + am * dans;
585  hold = am * pans;
586  probability = probability + hold;
587  if ((pans * sum < eps2) && (hold < eps2)) break; // converged
588  }
589  if (m == maxit) THROW_EXCEPTION("noncentralChi2PDF_CDF(): no convergence.");
590  return std::make_pair(
591  0.5 * ao * density, std::min(1.0, std::max(0.0, ao * probability)));
592 }
593 
595  unsigned int degreesOfFreedom, double arg, double accuracy)
596 {
598  degreesOfFreedom, 0.0, arg, accuracy)
599  .first;
600 }
601 
603  unsigned int degreesOfFreedom, double noncentrality, double arg)
604 {
605  const double a = degreesOfFreedom + noncentrality;
606  const double b = (a + noncentrality) / square(a);
607  const double t =
608  (std::pow((double)arg / a, 1.0 / 3.0) - (1.0 - 2.0 / 9.0 * b)) /
609  std::sqrt(2.0 / 9.0 * b);
610  return 0.5 * (1.0 + std::erf(t / std::sqrt(2.0)));
611 }
612 
614 {
615  v.resize(s.ReadAs<uint32_t>());
616  if (v.size() > 0) s.ReadBufferFixEndianness(&v[0], v.size());
617  return s;
618 }
620 {
621  v.resize(s.ReadAs<uint32_t>());
622  if (v.size() > 0) s.ReadBufferFixEndianness(&v[0], v.size());
623  return s;
624 }
626 {
627  s.WriteAs<uint32_t>(v.size());
628  if (v.size() > 0) s.WriteBufferFixEndianness(&v[0], v.size());
629  return s;
630 }
632 {
633  s.WriteAs<uint32_t>(v.size());
634  if (v.size() > 0) s.WriteBufferFixEndianness(&v[0], v.size());
635  return s;
636 }
Scalar * iterator
Definition: eigen_plugins.h:26
double averageWrap2Pi(const CVectorDouble &angles)
Computes the average of a sequence of angles in radians taking into account the correct wrapping in t...
Definition: math.cpp:313
std::string MATLAB_plotCovariance2D(const CMatrixFloat &cov22, const CVectorFloat &mean, const float &stdCount, const std::string &style=std::string("b"), const size_t &nEllipsePoints=30)
Generates a string with the MATLAB commands required to plot an confidence interval (ellipse) for a 2...
Definition: math.cpp:354
#define MRPT_START
Definition: exceptions.h:262
GLdouble GLdouble t
Definition: glext.h:3689
GLdouble GLdouble z
Definition: glext.h:3872
This class is a "CSerializable" wrapper for "CMatrixTemplateNumeric<double>".
Definition: CMatrixD.h:24
#define min(a, b)
#define M_2PI
Definition: common.h:58
#define THROW_EXCEPTION(msg)
Definition: exceptions.h:41
double normalCDF(double p)
Evaluates the Gaussian cumulative density function.
Definition: math.cpp:133
GLdouble GLdouble GLdouble GLdouble q
Definition: glext.h:3721
GLenum GLsizei n
Definition: glext.h:5074
Column vector, like Eigen::MatrixX*, but automatically initialized to zeros since construction...
Definition: eigen_frwds.h:44
This file implements miscelaneous matrix and matrix/vector operations, and internal functions in mrpt...
STL namespace.
#define MRPT_END_WITH_CLEAN_UP(stuff)
Definition: exceptions.h:268
GLdouble s
Definition: glext.h:3676
T square(const T x)
Inline function for the square of a number.
double factorial(unsigned int n)
Computes the factorial of an integer number and returns it as a double value (internally it uses loga...
Definition: math.cpp:68
double normalQuantile(double p)
Evaluates the Gaussian distribution quantile for the probability value p=[0,1].
Definition: math.cpp:80
#define ASSERT_(f)
Defines an assertion mechanism.
Definition: exceptions.h:113
This base provides a set of functions for maths stuff.
std::pair< double, double > noncentralChi2PDF_CDF(unsigned int degreesOfFreedom, double noncentrality, double arg, double eps=1e-7)
Returns the &#39;exact&#39; PDF (first) and CDF (second) of a Non-central chi-squared probability distributio...
Definition: math.cpp:527
#define MRPT_CHECK_NORMAL_NUMBER(v)
Throws an exception if the number is NaN, IND, or +/-INF, or return the same number otherwise...
Definition: exceptions.h:118
double averageLogLikelihood(const CVectorDouble &logLikelihoods)
A numerically-stable method to compute average likelihood values with strongly different ranges (unwe...
Definition: math.cpp:291
std::ostream & operator<<(std::ostream &o, const TPoint2D &p)
const GLubyte * c
Definition: glext.h:6313
bool loadVector(std::istream &f, std::vector< int > &d)
Loads one row of a text file as a numerical std::vector.
double chi2PDF(unsigned int degreesOfFreedom, double arg, double accuracy=1e-7)
Definition: math.cpp:594
char * strtok(char *str, const char *strDelimit, char **context) noexcept
An OS-independent method for tokenizing a string.
CONTAINER::Scalar sum(const CONTAINER &v)
Computes the sum of all the elements.
uint64_t factorial64(unsigned int n)
Computes the factorial of an integer number and returns it as a 64-bit integer number.
Definition: math.cpp:56
std::string format(const char *fmt,...) MRPT_printf_format_check(1
A std::string version of C sprintf.
Definition: format.cpp:16
GLubyte GLubyte b
Definition: glext.h:6279
const double eps
#define ASSERTMSG_(f, __ERROR_MSG)
Defines an assertion mechanism.
Definition: exceptions.h:101
CONTAINER::Scalar maximum(const CONTAINER &v)
GLsizei const GLchar ** string
Definition: glext.h:4101
T wrapToPi(T a)
Modifies the given angle to translate it into the ]-pi,pi] range.
Definition: wrap2pi.h:53
double chi2CDF(unsigned int degreesOfFreedom, double arg)
Definition: math.cpp:504
void medianFilter(const std::vector< double > &inV, std::vector< double > &outV, const int &winSize, const int &numberOfSigmas=2)
Definition: math.cpp:460
void noncentralChi2OneIteration(T arg, T &lans, T &dans, T &pans, unsigned int &j)
Definition: math.cpp:510
unsigned __int64 uint64_t
Definition: rptypes.h:50
const GLdouble * v
Definition: glext.h:3678
This is the global namespace for all Mobile Robot Programming Toolkit (MRPT) libraries.
Virtual base class for "archives": classes abstracting I/O streams.
Definition: CArchive.h:48
double chi2inv(double P, unsigned int dim=1)
The "quantile" of the Chi-Square distribution, for dimension "dim" and probability 0<P<1 (the inverse...
Definition: math.cpp:42
GLdouble GLdouble GLdouble r
Definition: glext.h:3705
#define MRPT_END
Definition: exceptions.h:266
double mean(const CONTAINER &v)
Computes the mean value of a vector.
GLenum GLint GLint y
Definition: glext.h:3538
double noncentralChi2CDF(unsigned int degreesOfFreedom, double noncentrality, double arg)
Definition: math.cpp:602
Eigen::Matrix< typename MATRIX::Scalar, MATRIX::ColsAtCompileTime, MATRIX::ColsAtCompileTime > cov(const MATRIX &v)
Computes the covariance matrix from a list of samples in an NxM matrix, where each row is a sample...
Definition: ops_matrices.h:148
double interpolate2points(const double x, const double x0, const double y0, const double x1, const double y1, bool wrap2pi=false)
Linear interpolation/extrapolation: evaluates at "x" the line (x0,y0)-(x1,y1).
Definition: math.cpp:436
GLuint res
Definition: glext.h:7268
GLenum GLint x
Definition: glext.h:3538
#define THROW_EXCEPTION_FMT(_FORMAT_STRING,...)
Definition: exceptions.h:43
unsigned __int32 uint32_t
Definition: rptypes.h:47
size_t ReadBufferFixEndianness(T *ptr, size_t ElementCount)
Reads a sequence of elemental datatypes, taking care of reordering their bytes from the MRPT stream s...
Definition: CArchive.h:84
double normalPDF(double x, double mu, double std)
Evaluates the univariate normal (Gaussian) distribution at a given point "x".
Definition: math.cpp:33
GLubyte GLubyte GLubyte a
Definition: glext.h:6279
GLfloat GLfloat p
Definition: glext.h:6305
const Scalar * const_iterator
Definition: eigen_plugins.h:27
mrpt::serialization::CArchive & operator>>(mrpt::serialization::CArchive &in, CMatrix::Ptr &pObj)
#define MRPT_UNUSED_PARAM(a)
Determines whether this is an X86 or AMD64 platform.
Definition: common.h:186



Page generated by Doxygen 1.8.14 for MRPT 1.9.9 Git: ad3a9d8ae Tue May 1 23:10:22 2018 -0700 at lun oct 28 00:14:14 CET 2019