gtsam 4.2.0
gtsam
Loading...
Searching...
No Matches
NoiseModel.h
Go to the documentation of this file.
1/* ----------------------------------------------------------------------------
2
3 * GTSAM Copyright 2010, Georgia Tech Research Corporation,
4 * Atlanta, Georgia 30332-0415
5 * All Rights Reserved
6 * Authors: Frank Dellaert, et al. (see THANKS for the full author list)
7
8 * See LICENSE for the license information
9
10 * -------------------------------------------------------------------------- */
11
19#pragma once
20
21#include <gtsam/base/Testable.h>
22#include <gtsam/base/Matrix.h>
23#include <gtsam/dllexport.h>
24#include <gtsam/linear/LossFunctions.h>
25
26#include <boost/serialization/nvp.hpp>
27#include <boost/serialization/extended_type_info.hpp>
28#include <boost/serialization/singleton.hpp>
29#include <boost/serialization/shared_ptr.hpp>
30#include <boost/serialization/optional.hpp>
31
32namespace gtsam {
33
35 namespace noiseModel {
36
37 // Forward declaration
38 class Gaussian;
39 class Diagonal;
40 class Constrained;
41 class Isotropic;
42 class Unit;
43 class RobustModel;
44
45 //---------------------------------------------------------------------------------------
46
53 class GTSAM_EXPORT Base {
54
55 public:
56 typedef boost::shared_ptr<Base> shared_ptr;
57
58 protected:
59
60 size_t dim_;
61
62 public:
63
65 Base(size_t dim = 1):dim_(dim) {}
66 virtual ~Base() {}
67
69 virtual bool isConstrained() const { return false; } // default false
70
72 virtual bool isUnit() const { return false; } // default false
73
75 inline size_t dim() const { return dim_;}
76
77 virtual void print(const std::string& name = "") const = 0;
78
79 virtual bool equals(const Base& expected, double tol=1e-9) const = 0;
80
82 virtual Vector sigmas() const;
83
85 virtual Vector whiten(const Vector& v) const = 0;
86
88 virtual Matrix Whiten(const Matrix& H) const = 0;
89
91 virtual Vector unwhiten(const Vector& v) const = 0;
92
94 virtual double squaredMahalanobisDistance(const Vector& v) const;
95
97 virtual double mahalanobisDistance(const Vector& v) const {
98 return std::sqrt(squaredMahalanobisDistance(v));
99 }
100
102 virtual double loss(const double squared_distance) const {
103 return 0.5 * squared_distance;
104 }
105
106 virtual void WhitenSystem(std::vector<Matrix>& A, Vector& b) const = 0;
107 virtual void WhitenSystem(Matrix& A, Vector& b) const = 0;
108 virtual void WhitenSystem(Matrix& A1, Matrix& A2, Vector& b) const = 0;
109 virtual void WhitenSystem(Matrix& A1, Matrix& A2, Matrix& A3, Vector& b) const = 0;
110
112 virtual void whitenInPlace(Vector& v) const {
113 v = whiten(v);
114 }
115
117 virtual void unwhitenInPlace(Vector& v) const {
118 v = unwhiten(v);
119 }
120
122 virtual void whitenInPlace(Eigen::Block<Vector>& v) const {
123 v = whiten(v);
124 }
125
127 virtual void unwhitenInPlace(Eigen::Block<Vector>& v) const {
128 v = unwhiten(v);
129 }
130
132 virtual Vector unweightedWhiten(const Vector& v) const {
133 return whiten(v);
134 }
135
137 virtual double weight(const Vector& v) const { return 1.0; }
138
139 private:
141 friend class boost::serialization::access;
142 template<class ARCHIVE>
143 void serialize(ARCHIVE & ar, const unsigned int /*version*/) {
144 ar & BOOST_SERIALIZATION_NVP(dim_);
145 }
146 };
147
148 //---------------------------------------------------------------------------------------
149
162 class GTSAM_EXPORT Gaussian: public Base {
163
164 protected:
165
167 boost::optional<Matrix> sqrt_information_;
168
169 private:
170
174 const Matrix& thisR() const {
175 // should never happen
176 if (!sqrt_information_) throw std::runtime_error("Gaussian: has no R matrix");
177 return *sqrt_information_;
178 }
179
180
181 public:
182
183 typedef boost::shared_ptr<Gaussian> shared_ptr;
184
186 Gaussian(size_t dim = 1,
187 const boost::optional<Matrix>& sqrt_information = boost::none)
188 : Base(dim), sqrt_information_(sqrt_information) {}
189
190 ~Gaussian() override {}
191
197 static shared_ptr SqrtInformation(const Matrix& R, bool smart = true);
198
204 static shared_ptr Information(const Matrix& M, bool smart = true);
205
211 static shared_ptr Covariance(const Matrix& covariance, bool smart = true);
212
213 void print(const std::string& name) const override;
214 bool equals(const Base& expected, double tol=1e-9) const override;
215 Vector sigmas() const override;
216 Vector whiten(const Vector& v) const override;
217 Vector unwhiten(const Vector& v) const override;
218
223 Matrix Whiten(const Matrix& H) const override;
224
228 virtual void WhitenInPlace(Matrix& H) const;
229
233 virtual void WhitenInPlace(Eigen::Block<Matrix> H) const;
234
238 void WhitenSystem(std::vector<Matrix>& A, Vector& b) const override;
239 void WhitenSystem(Matrix& A, Vector& b) const override;
240 void WhitenSystem(Matrix& A1, Matrix& A2, Vector& b) const override;
241 void WhitenSystem(Matrix& A1, Matrix& A2, Matrix& A3, Vector& b) const override;
242
252 virtual boost::shared_ptr<Diagonal> QR(Matrix& Ab) const;
253
255 virtual Matrix R() const { return thisR();}
256
258 virtual Matrix information() const;
259
261 virtual Matrix covariance() const;
262
263 private:
265 friend class boost::serialization::access;
266 template<class ARCHIVE>
267 void serialize(ARCHIVE & ar, const unsigned int /*version*/) {
268 ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(Base);
269 ar & BOOST_SERIALIZATION_NVP(sqrt_information_);
270 }
271
272 }; // Gaussian
273
274 //---------------------------------------------------------------------------------------
275
281 class GTSAM_EXPORT Diagonal : public Gaussian {
282 protected:
283
289 Vector sigmas_, invsigmas_, precisions_;
290
291 protected:
292
294 Diagonal(const Vector& sigmas);
295
296 public:
298 Diagonal();
299
300 typedef boost::shared_ptr<Diagonal> shared_ptr;
301
302 ~Diagonal() override {}
303
308 static shared_ptr Sigmas(const Vector& sigmas, bool smart = true);
309
316 static shared_ptr Variances(const Vector& variances, bool smart = true);
317
322 static shared_ptr Precisions(const Vector& precisions, bool smart = true);
323
324 void print(const std::string& name) const override;
325 Vector sigmas() const override { return sigmas_; }
326 Vector whiten(const Vector& v) const override;
327 Vector unwhiten(const Vector& v) const override;
328 Matrix Whiten(const Matrix& H) const override;
329 void WhitenInPlace(Matrix& H) const override;
330 void WhitenInPlace(Eigen::Block<Matrix> H) const override;
331
335 inline double sigma(size_t i) const { return sigmas_(i); }
336
340 inline const Vector& invsigmas() const { return invsigmas_; }
341 inline double invsigma(size_t i) const {return invsigmas_(i);}
342
346 inline const Vector& precisions() const { return precisions_; }
347 inline double precision(size_t i) const {return precisions_(i);}
348
352 Matrix R() const override {
353 return invsigmas().asDiagonal();
354 }
355
356 private:
358 friend class boost::serialization::access;
359 template<class ARCHIVE>
360 void serialize(ARCHIVE & ar, const unsigned int /*version*/) {
361 ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(Gaussian);
362 ar & BOOST_SERIALIZATION_NVP(sigmas_);
363 ar & BOOST_SERIALIZATION_NVP(invsigmas_);
364 }
365 }; // Diagonal
366
367 //---------------------------------------------------------------------------------------
368
381 class GTSAM_EXPORT Constrained : public Diagonal {
382 protected:
383
384 // Sigmas are contained in the base class
385 Vector mu_;
386
392 Constrained(const Vector& mu, const Vector& sigmas);
393
394 public:
395
396 typedef boost::shared_ptr<Constrained> shared_ptr;
397
404 Constrained(const Vector& sigmas = Z_1x1);
405
406 ~Constrained() override {}
407
409 bool isConstrained() const override { return true; }
410
412 bool constrained(size_t i) const;
413
415 const Vector& mu() const { return mu_; }
416
421 static shared_ptr MixedSigmas(const Vector& mu, const Vector& sigmas);
422
427 static shared_ptr MixedSigmas(const Vector& sigmas);
428
433 static shared_ptr MixedSigmas(double m, const Vector& sigmas);
434
439 static shared_ptr MixedVariances(const Vector& mu, const Vector& variances);
440 static shared_ptr MixedVariances(const Vector& variances);
441
446 static shared_ptr MixedPrecisions(const Vector& mu, const Vector& precisions);
447 static shared_ptr MixedPrecisions(const Vector& precisions);
448
454 double squaredMahalanobisDistance(const Vector& v) const override;
455
457 static shared_ptr All(size_t dim) {
458 return shared_ptr(new Constrained(Vector::Constant(dim, 1000.0), Vector::Constant(dim,0)));
459 }
460
462 static shared_ptr All(size_t dim, const Vector& mu) {
463 return shared_ptr(new Constrained(mu, Vector::Constant(dim,0)));
464 }
465
467 static shared_ptr All(size_t dim, double mu) {
468 return shared_ptr(new Constrained(Vector::Constant(dim, mu), Vector::Constant(dim,0)));
469 }
470
471 void print(const std::string& name) const override;
472
474 Vector whiten(const Vector& v) const override;
475
478 Matrix Whiten(const Matrix& H) const override;
479 void WhitenInPlace(Matrix& H) const override;
480 void WhitenInPlace(Eigen::Block<Matrix> H) const override;
481
491 Diagonal::shared_ptr QR(Matrix& Ab) const override;
492
497 shared_ptr unit() const;
498
499 private:
501 friend class boost::serialization::access;
502 template<class ARCHIVE>
503 void serialize(ARCHIVE & ar, const unsigned int /*version*/) {
504 ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(Diagonal);
505 ar & BOOST_SERIALIZATION_NVP(mu_);
506 }
507
508 }; // Constrained
509
510 //---------------------------------------------------------------------------------------
511
516 class GTSAM_EXPORT Isotropic : public Diagonal {
517 protected:
518 double sigma_, invsigma_;
519
521 Isotropic(size_t dim, double sigma) :
522 Diagonal(Vector::Constant(dim, sigma)),sigma_(sigma),invsigma_(1.0/sigma) {}
523
524 public:
525
526 /* dummy constructor to allow for serialization */
527 Isotropic() : Diagonal(Vector1::Constant(1.0)),sigma_(1.0),invsigma_(1.0) {}
528
529 ~Isotropic() override {}
530
531 typedef boost::shared_ptr<Isotropic> shared_ptr;
532
536 static shared_ptr Sigma(size_t dim, double sigma, bool smart = true);
537
544 static shared_ptr Variance(size_t dim, double variance, bool smart = true);
545
549 static shared_ptr Precision(size_t dim, double precision, bool smart = true) {
550 return Variance(dim, 1.0/precision, smart);
551 }
552
553 void print(const std::string& name) const override;
554 double squaredMahalanobisDistance(const Vector& v) const override;
555 Vector whiten(const Vector& v) const override;
556 Vector unwhiten(const Vector& v) const override;
557 Matrix Whiten(const Matrix& H) const override;
558 void WhitenInPlace(Matrix& H) const override;
559 void whitenInPlace(Vector& v) const override;
560 void WhitenInPlace(Eigen::Block<Matrix> H) const override;
561
565 inline double sigma() const { return sigma_; }
566
567 private:
569 friend class boost::serialization::access;
570 template<class ARCHIVE>
571 void serialize(ARCHIVE & ar, const unsigned int /*version*/) {
572 ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(Diagonal);
573 ar & BOOST_SERIALIZATION_NVP(sigma_);
574 ar & BOOST_SERIALIZATION_NVP(invsigma_);
575 }
576
577 };
578
579 //---------------------------------------------------------------------------------------
580
584 class GTSAM_EXPORT Unit : public Isotropic {
585 public:
586
587 typedef boost::shared_ptr<Unit> shared_ptr;
588
590 Unit(size_t dim=1): Isotropic(dim,1.0) {}
591
592 ~Unit() override {}
593
597 static shared_ptr Create(size_t dim) {
598 return shared_ptr(new Unit(dim));
599 }
600
602 bool isUnit() const override { return true; }
603
604 void print(const std::string& name) const override;
605 double squaredMahalanobisDistance(const Vector& v) const override;
606 Vector whiten(const Vector& v) const override { return v; }
607 Vector unwhiten(const Vector& v) const override { return v; }
608 Matrix Whiten(const Matrix& H) const override { return H; }
609 void WhitenInPlace(Matrix& /*H*/) const override {}
610 void WhitenInPlace(Eigen::Block<Matrix> /*H*/) const override {}
611 void whitenInPlace(Vector& /*v*/) const override {}
612 void unwhitenInPlace(Vector& /*v*/) const override {}
613 void whitenInPlace(Eigen::Block<Vector>& /*v*/) const override {}
614 void unwhitenInPlace(Eigen::Block<Vector>& /*v*/) const override {}
615
616 private:
618 friend class boost::serialization::access;
619 template<class ARCHIVE>
620 void serialize(ARCHIVE & ar, const unsigned int /*version*/) {
621 ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(Isotropic);
622 }
623 };
624
642 class GTSAM_EXPORT Robust : public Base {
643 public:
644 typedef boost::shared_ptr<Robust> shared_ptr;
645
646 protected:
649
650 const RobustModel::shared_ptr robust_;
651 const NoiseModel::shared_ptr noise_;
652
653 public:
654
656 Robust() {};
657
659 Robust(const RobustModel::shared_ptr robust, const NoiseModel::shared_ptr noise)
660 : Base(noise->dim()), robust_(robust), noise_(noise) {}
661
663 ~Robust() override {}
664
665 void print(const std::string& name) const override;
666 bool equals(const Base& expected, double tol=1e-9) const override;
667
669 const RobustModel::shared_ptr& robust() const { return robust_; }
670
672 const NoiseModel::shared_ptr& noise() const { return noise_; }
673
674 // Functions below are dummy but necessary for the noiseModel::Base
675 inline Vector whiten(const Vector& v) const override
676 { Vector r = v; this->WhitenSystem(r); return r; }
677 inline Matrix Whiten(const Matrix& A) const override
678 { Vector b; Matrix B=A; this->WhitenSystem(B,b); return B; }
679 inline Vector unwhiten(const Vector& /*v*/) const override
680 { throw std::invalid_argument("unwhiten is not currently supported for robust noise models."); }
682 double loss(const double squared_distance) const override {
683 return robust_->loss(std::sqrt(squared_distance));
684 }
685
686 // NOTE: This is special because in whiten the base version will do the reweighting
687 // which is incorrect!
688 double squaredMahalanobisDistance(const Vector& v) const override {
689 return noise_->squaredMahalanobisDistance(v);
690 }
691
692 // These are really robust iterated re-weighting support functions
693 virtual void WhitenSystem(Vector& b) const;
694 void WhitenSystem(std::vector<Matrix>& A, Vector& b) const override;
695 void WhitenSystem(Matrix& A, Vector& b) const override;
696 void WhitenSystem(Matrix& A1, Matrix& A2, Vector& b) const override;
697 void WhitenSystem(Matrix& A1, Matrix& A2, Matrix& A3, Vector& b) const override;
698
699 Vector unweightedWhiten(const Vector& v) const override;
700 double weight(const Vector& v) const override;
701
702 static shared_ptr Create(
703 const RobustModel::shared_ptr &robust, const NoiseModel::shared_ptr noise);
704
705 private:
707 friend class boost::serialization::access;
708 template<class ARCHIVE>
709 void serialize(ARCHIVE & ar, const unsigned int /*version*/) {
710 ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(Base);
711 ar & boost::serialization::make_nvp("robust_", const_cast<RobustModel::shared_ptr&>(robust_));
712 ar & boost::serialization::make_nvp("noise_", const_cast<NoiseModel::shared_ptr&>(noise_));
713 }
714 };
715
716 // Helper function
717 GTSAM_EXPORT boost::optional<Vector> checkIfDiagonal(const Matrix& M);
718
719 } // namespace noiseModel
720
724 typedef noiseModel::Base::shared_ptr SharedNoiseModel;
725 typedef noiseModel::Gaussian::shared_ptr SharedGaussian;
726 typedef noiseModel::Diagonal::shared_ptr SharedDiagonal;
727 typedef noiseModel::Constrained::shared_ptr SharedConstrained;
728 typedef noiseModel::Isotropic::shared_ptr SharedIsotropic;
729
731 template<> struct traits<noiseModel::Gaussian> : public Testable<noiseModel::Gaussian> {};
732 template<> struct traits<noiseModel::Diagonal> : public Testable<noiseModel::Diagonal> {};
733 template<> struct traits<noiseModel::Constrained> : public Testable<noiseModel::Constrained> {};
734 template<> struct traits<noiseModel::Isotropic> : public Testable<noiseModel::Isotropic> {};
735 template<> struct traits<noiseModel::Unit> : public Testable<noiseModel::Unit> {};
736
737} //\ namespace gtsam
738
739
typedef and functions to augment Eigen's MatrixXd
Concept check for values that can be used in unit tests.
Global functions in a separate testing namespace.
Definition chartTesting.h:28
void print(const Matrix &A, const string &s, ostream &stream)
print without optional string, must specify cout yourself
Definition Matrix.cpp:156
noiseModel::Base::shared_ptr SharedNoiseModel
Aliases.
Definition NoiseModel.h:724
A manifold defines a space in which there is a notion of a linear tangent space that can be centered ...
Definition concepts.h:30
Template to create a binary predicate.
Definition Testable.h:111
A helper that implements the traits interface for GTSAM types.
Definition Testable.h:151
Pure virtual class for all robust error function classes.
Definition LossFunctions.h:63
noiseModel::Base is the abstract base class for all noise models.
Definition NoiseModel.h:53
virtual bool isConstrained() const
true if a constrained noise model, saves slow/clumsy dynamic casting
Definition NoiseModel.h:69
virtual void whitenInPlace(Vector &v) const
in-place whiten, override if can be done more efficiently
Definition NoiseModel.h:112
size_t dim() const
Dimensionality.
Definition NoiseModel.h:75
virtual void unwhitenInPlace(Eigen::Block< Vector > &v) const
in-place unwhiten, override if can be done more efficiently
Definition NoiseModel.h:127
virtual void whitenInPlace(Eigen::Block< Vector > &v) const
in-place whiten, override if can be done more efficiently
Definition NoiseModel.h:122
virtual Vector whiten(const Vector &v) const =0
Whiten an error vector.
virtual double mahalanobisDistance(const Vector &v) const
Mahalanobis distance.
Definition NoiseModel.h:97
virtual bool isUnit() const
true if a unit noise model, saves slow/clumsy dynamic casting
Definition NoiseModel.h:72
virtual double weight(const Vector &v) const
get the weight from the effective loss function on residual vector v
Definition NoiseModel.h:137
virtual Vector unweightedWhiten(const Vector &v) const
Useful function for robust noise models to get the unweighted but whitened error.
Definition NoiseModel.h:132
virtual Vector unwhiten(const Vector &v) const =0
Unwhiten an error vector.
virtual double loss(const double squared_distance) const
loss function, input is Mahalanobis distance
Definition NoiseModel.h:102
virtual void unwhitenInPlace(Vector &v) const
in-place unwhiten, override if can be done more efficiently
Definition NoiseModel.h:117
virtual Matrix Whiten(const Matrix &H) const =0
Whiten a matrix.
Base(size_t dim=1)
primary constructor
Definition NoiseModel.h:65
Gaussian implements the mathematical model |R*x|^2 = |y|^2 with R'*R=inv(Sigma) where y = whiten(x) =...
Definition NoiseModel.h:162
virtual Matrix R() const
Return R itself, but note that Whiten(H) is cheaper than R*H.
Definition NoiseModel.h:255
Gaussian(size_t dim=1, const boost::optional< Matrix > &sqrt_information=boost::none)
constructor takes square root information matrix
Definition NoiseModel.h:186
boost::optional< Matrix > sqrt_information_
Matrix square root of information matrix (R)
Definition NoiseModel.h:167
A diagonal noise model implements a diagonal covariance matrix, with the elements of the diagonal spe...
Definition NoiseModel.h:281
Matrix R() const override
Return R itself, but note that Whiten(H) is cheaper than R*H.
Definition NoiseModel.h:352
Vector sigmas_
Standard deviations (sigmas), their inverse and inverse square (weights/precisions) These are all com...
Definition NoiseModel.h:289
double sigma(size_t i) const
Return standard deviations (sqrt of diagonal)
Definition NoiseModel.h:335
const Vector & invsigmas() const
Return sqrt precisions.
Definition NoiseModel.h:340
Vector sigmas() const override
Calculate standard deviations.
Definition NoiseModel.h:325
const Vector & precisions() const
Return precisions.
Definition NoiseModel.h:346
A Constrained constrained model is a specialization of Diagonal which allows some or all of the sigma...
Definition NoiseModel.h:381
bool isConstrained() const override
true if a constrained noise mode, saves slow/clumsy dynamic casting
Definition NoiseModel.h:409
static shared_ptr All(size_t dim, const Vector &mu)
Fully constrained variations.
Definition NoiseModel.h:462
static shared_ptr All(size_t dim, double mu)
Fully constrained variations with a mu parameter.
Definition NoiseModel.h:467
static shared_ptr All(size_t dim)
Fully constrained variations.
Definition NoiseModel.h:457
const Vector & mu() const
Access mu as a vector.
Definition NoiseModel.h:415
Vector mu_
Penalty function weight - needs to be large enough to dominate soft constraints.
Definition NoiseModel.h:385
An isotropic noise model corresponds to a scaled diagonal covariance To construct,...
Definition NoiseModel.h:516
double sigma() const
Return standard deviation.
Definition NoiseModel.h:565
static shared_ptr Precision(size_t dim, double precision, bool smart=true)
An isotropic noise model created by specifying a precision.
Definition NoiseModel.h:549
Isotropic(size_t dim, double sigma)
protected constructor takes sigma
Definition NoiseModel.h:521
Unit: i.i.d.
Definition NoiseModel.h:584
void WhitenInPlace(Eigen::Block< Matrix >) const override
In-place version.
Definition NoiseModel.h:610
Vector unwhiten(const Vector &v) const override
Unwhiten an error vector.
Definition NoiseModel.h:607
void whitenInPlace(Eigen::Block< Vector > &) const override
in-place whiten, override if can be done more efficiently
Definition NoiseModel.h:613
bool isUnit() const override
true if a unit noise model, saves slow/clumsy dynamic casting
Definition NoiseModel.h:602
Unit(size_t dim=1)
constructor for serialization
Definition NoiseModel.h:590
Vector whiten(const Vector &v) const override
Whiten an error vector.
Definition NoiseModel.h:606
static shared_ptr Create(size_t dim)
Create a unit covariance noise model.
Definition NoiseModel.h:597
void unwhitenInPlace(Vector &) const override
in-place unwhiten, override if can be done more efficiently
Definition NoiseModel.h:612
void unwhitenInPlace(Eigen::Block< Vector > &) const override
in-place unwhiten, override if can be done more efficiently
Definition NoiseModel.h:614
void whitenInPlace(Vector &) const override
in-place whiten, override if can be done more efficiently
Definition NoiseModel.h:611
void WhitenInPlace(Matrix &) const override
In-place version.
Definition NoiseModel.h:609
Matrix Whiten(const Matrix &H) const override
Whiten a matrix.
Definition NoiseModel.h:608
Base class for robust error models The robust M-estimators above simply tell us how to re-weight the ...
Definition NoiseModel.h:642
const RobustModel::shared_ptr & robust() const
Return the contained robust error function.
Definition NoiseModel.h:669
Robust()
Default Constructor for serialization.
Definition NoiseModel.h:656
Robust(const RobustModel::shared_ptr robust, const NoiseModel::shared_ptr noise)
Constructor.
Definition NoiseModel.h:659
double squaredMahalanobisDistance(const Vector &v) const override
Squared Mahalanobis distance v'*R'*R*v = <R*v,R*v>
Definition NoiseModel.h:688
const NoiseModel::shared_ptr noise_
noise model used
Definition NoiseModel.h:651
double loss(const double squared_distance) const override
Compute loss from the m-estimator using the Mahalanobis distance.
Definition NoiseModel.h:682
Vector unwhiten(const Vector &) const override
Unwhiten an error vector.
Definition NoiseModel.h:679
Matrix Whiten(const Matrix &A) const override
Whiten a matrix.
Definition NoiseModel.h:677
const RobustModel::shared_ptr robust_
robust error function used
Definition NoiseModel.h:650
~Robust() override
Destructor.
Definition NoiseModel.h:663
const NoiseModel::shared_ptr & noise() const
Return the contained noise model.
Definition NoiseModel.h:672
Vector whiten(const Vector &v) const override
Whiten an error vector.
Definition NoiseModel.h:675