LossFunctions.h
Go to the documentation of this file.
1 
2 /* ----------------------------------------------------------------------------
3 
4  * GTSAM Copyright 2010, Georgia Tech Research Corporation,
5  * Atlanta, Georgia 30332-0415
6  * All Rights Reserved
7  * Authors: Frank Dellaert, et al. (see THANKS for the full author list)
8 
9  * See LICENSE for the license information
10 
11  * -------------------------------------------------------------------------- */
12 
21 #pragma once
22 
23 #include <gtsam/base/Matrix.h>
24 #include <gtsam/base/Testable.h>
25 #include <gtsam/dllexport.h>
26 
27 #ifdef GTSAM_ENABLE_BOOST_SERIALIZATION
28 #include <boost/serialization/extended_type_info.hpp>
29 #include <boost/serialization/nvp.hpp>
30 #include <boost/serialization/version.hpp>
31 #include <boost/serialization/optional.hpp>
32 #include <boost/serialization/shared_ptr.hpp>
33 #include <boost/serialization/singleton.hpp>
34 #endif
35 
36 namespace gtsam {
37 namespace noiseModel {
38 // clang-format off
57 // clang-format on
58 namespace mEstimator {
59 
66 class GTSAM_EXPORT Base {
67  public:
70  enum ReweightScheme { Scalar, Block };
71  typedef std::shared_ptr<Base> shared_ptr;
72 
73  protected:
76 
77  public:
78  Base(const ReweightScheme reweight = Block) : reweight_(reweight) {}
79  virtual ~Base() {}
80 
82  ReweightScheme reweightScheme() const { return reweight_; }
83 
97  virtual double loss(double distance) const { return 0; }
98 
109  virtual double weight(double distance) const = 0;
110 
111  virtual void print(const std::string &s) const = 0;
112  virtual bool equals(const Base &expected, double tol = 1e-8) const = 0;
113 
114  double sqrtWeight(double distance) const { return std::sqrt(weight(distance)); }
115 
118  Vector weight(const Vector &error) const;
119 
121  Vector sqrtWeight(const Vector &error) const;
122 
125  void reweight(Vector &error) const;
126  void reweight(std::vector<Matrix> &A, Vector &error) const;
127  void reweight(Matrix &A, Vector &error) const;
128  void reweight(Matrix &A1, Matrix &A2, Vector &error) const;
129  void reweight(Matrix &A1, Matrix &A2, Matrix &A3, Vector &error) const;
130 
131  private:
132 #ifdef GTSAM_ENABLE_BOOST_SERIALIZATION
133 
134  friend class boost::serialization::access;
135  template <class ARCHIVE>
136  void serialize(ARCHIVE &ar, const unsigned int /*version*/) {
137  ar &BOOST_SERIALIZATION_NVP(reweight_);
138  }
139 #endif
140 };
141 
151 class GTSAM_EXPORT Null : public Base {
152  public:
153  typedef std::shared_ptr<Null> shared_ptr;
154 
155  Null(const ReweightScheme reweight = Block) : Base(reweight) {}
156  ~Null() override {}
157  double weight(double /*error*/) const override { return 1.0; }
158  double loss(double distance) const override { return 0.5 * distance * distance; }
159  void print(const std::string &s) const override;
160  bool equals(const Base & /*expected*/, double /*tol*/) const override { return true; }
161  static shared_ptr Create();
162 
163  private:
164 #ifdef GTSAM_ENABLE_BOOST_SERIALIZATION
165 
166  friend class boost::serialization::access;
167  template <class ARCHIVE>
168  void serialize(ARCHIVE &ar, const unsigned int /*version*/) {
169  ar &BOOST_SERIALIZATION_BASE_OBJECT_NVP(Base);
170  }
171 #endif
172 };
173 
182 class GTSAM_EXPORT Fair : public Base {
183  protected:
184  double c_;
185 
186  public:
187  typedef std::shared_ptr<Fair> shared_ptr;
188 
189  Fair(double c = 1.3998, const ReweightScheme reweight = Block);
190  double weight(double distance) const override;
191  double loss(double distance) const override;
192  void print(const std::string &s) const override;
193  bool equals(const Base &expected, double tol = 1e-8) const override;
194  static shared_ptr Create(double c, const ReweightScheme reweight = Block);
195  double modelParameter() const { return c_; }
196 
197  private:
198 #ifdef GTSAM_ENABLE_BOOST_SERIALIZATION
199 
200  friend class boost::serialization::access;
201  template <class ARCHIVE>
202  void serialize(ARCHIVE &ar, const unsigned int /*version*/) {
203  ar &BOOST_SERIALIZATION_BASE_OBJECT_NVP(Base);
204  ar &BOOST_SERIALIZATION_NVP(c_);
205  }
206 #endif
207 };
208 
217 class GTSAM_EXPORT Huber : public Base {
218  protected:
219  double k_;
220 
221  public:
222  typedef std::shared_ptr<Huber> shared_ptr;
223 
224  Huber(double k = 1.345, const ReweightScheme reweight = Block);
225  double weight(double distance) const override;
226  double loss(double distance) const override;
227  void print(const std::string &s) const override;
228  bool equals(const Base &expected, double tol = 1e-8) const override;
229  static shared_ptr Create(double k, const ReweightScheme reweight = Block);
230  double modelParameter() const { return k_; }
231 
232  private:
233 #ifdef GTSAM_ENABLE_BOOST_SERIALIZATION
234 
235  friend class boost::serialization::access;
236  template <class ARCHIVE>
237  void serialize(ARCHIVE &ar, const unsigned int /*version*/) {
238  ar &BOOST_SERIALIZATION_BASE_OBJECT_NVP(Base);
239  ar &BOOST_SERIALIZATION_NVP(k_);
240  }
241 #endif
242 };
243 
257 class GTSAM_EXPORT Cauchy : public Base {
258  protected:
259  double k_, ksquared_;
260 
261  public:
262  typedef std::shared_ptr<Cauchy> shared_ptr;
263 
264  Cauchy(double k = 0.1, const ReweightScheme reweight = Block);
265  double weight(double distance) const override;
266  double loss(double distance) const override;
267  void print(const std::string &s) const override;
268  bool equals(const Base &expected, double tol = 1e-8) const override;
269  static shared_ptr Create(double k, const ReweightScheme reweight = Block);
270  double modelParameter() const { return k_; }
271 
272  private:
273 #ifdef GTSAM_ENABLE_BOOST_SERIALIZATION
274 
275  friend class boost::serialization::access;
276  template <class ARCHIVE>
277  void serialize(ARCHIVE &ar, const unsigned int /*version*/) {
278  ar &BOOST_SERIALIZATION_BASE_OBJECT_NVP(Base);
279  ar &BOOST_SERIALIZATION_NVP(k_);
280  ar &BOOST_SERIALIZATION_NVP(ksquared_);
281  }
282 #endif
283 };
284 
293 class GTSAM_EXPORT Tukey : public Base {
294  protected:
295  double c_, csquared_;
296 
297  public:
298  typedef std::shared_ptr<Tukey> shared_ptr;
299 
300  Tukey(double c = 4.6851, const ReweightScheme reweight = Block);
301  double weight(double distance) const override;
302  double loss(double distance) const override;
303  void print(const std::string &s) const override;
304  bool equals(const Base &expected, double tol = 1e-8) const override;
305  static shared_ptr Create(double k, const ReweightScheme reweight = Block);
306  double modelParameter() const { return c_; }
307 
308  private:
309 #ifdef GTSAM_ENABLE_BOOST_SERIALIZATION
310 
311  friend class boost::serialization::access;
312  template <class ARCHIVE>
313  void serialize(ARCHIVE &ar, const unsigned int /*version*/) {
314  ar &BOOST_SERIALIZATION_BASE_OBJECT_NVP(Base);
315  ar &BOOST_SERIALIZATION_NVP(c_);
316  }
317 #endif
318 };
319 
328 class GTSAM_EXPORT Welsch : public Base {
329  protected:
330  double c_, csquared_;
331 
332  public:
333  typedef std::shared_ptr<Welsch> shared_ptr;
334 
335  Welsch(double c = 2.9846, const ReweightScheme reweight = Block);
336  double weight(double distance) const override;
337  double loss(double distance) const override;
338  void print(const std::string &s) const override;
339  bool equals(const Base &expected, double tol = 1e-8) const override;
340  static shared_ptr Create(double k, const ReweightScheme reweight = Block);
341  double modelParameter() const { return c_; }
342 
343  private:
344 #ifdef GTSAM_ENABLE_BOOST_SERIALIZATION
345 
346  friend class boost::serialization::access;
347  template <class ARCHIVE>
348  void serialize(ARCHIVE &ar, const unsigned int /*version*/) {
349  ar &BOOST_SERIALIZATION_BASE_OBJECT_NVP(Base);
350  ar &BOOST_SERIALIZATION_NVP(c_);
351  ar &BOOST_SERIALIZATION_NVP(csquared_);
352  }
353 #endif
354 };
355 
366 class GTSAM_EXPORT GemanMcClure : public Base {
367  public:
368  typedef std::shared_ptr<GemanMcClure> shared_ptr;
369 
370  GemanMcClure(double c = 1.0, const ReweightScheme reweight = Block);
371  ~GemanMcClure() override {}
372  double weight(double distance) const override;
373  double loss(double distance) const override;
374  void print(const std::string &s) const override;
375  bool equals(const Base &expected, double tol = 1e-8) const override;
376  static shared_ptr Create(double k, const ReweightScheme reweight = Block);
377  double modelParameter() const { return c_; }
378 
379  protected:
380  double c_;
381 
382  private:
383 #ifdef GTSAM_ENABLE_BOOST_SERIALIZATION
384 
385  friend class boost::serialization::access;
386  template <class ARCHIVE>
387  void serialize(ARCHIVE &ar, const unsigned int /*version*/) {
388  ar &BOOST_SERIALIZATION_BASE_OBJECT_NVP(Base);
389  ar &BOOST_SERIALIZATION_NVP(c_);
390  }
391 #endif
392 };
393 
406 class GTSAM_EXPORT DCS : public Base {
407  public:
408  typedef std::shared_ptr<DCS> shared_ptr;
409 
410  DCS(double c = 1.0, const ReweightScheme reweight = Block);
411  ~DCS() override {}
412  double weight(double distance) const override;
413  double loss(double distance) const override;
414  void print(const std::string &s) const override;
415  bool equals(const Base &expected, double tol = 1e-8) const override;
416  static shared_ptr Create(double k, const ReweightScheme reweight = Block);
417  double modelParameter() const { return c_; }
418 
419  protected:
420  double c_;
421 
422  private:
423 #ifdef GTSAM_ENABLE_BOOST_SERIALIZATION
424 
425  friend class boost::serialization::access;
426  template <class ARCHIVE>
427  void serialize(ARCHIVE &ar, const unsigned int /*version*/) {
428  ar &BOOST_SERIALIZATION_BASE_OBJECT_NVP(Base);
429  ar &BOOST_SERIALIZATION_NVP(c_);
430  }
431 #endif
432 };
433 
447 class GTSAM_EXPORT L2WithDeadZone : public Base {
448  protected:
449  double k_;
450 
451  public:
452  typedef std::shared_ptr<L2WithDeadZone> shared_ptr;
453 
454  L2WithDeadZone(double k = 1.0, const ReweightScheme reweight = Block);
455  double weight(double distance) const override;
456  double loss(double distance) const override;
457  void print(const std::string &s) const override;
458  bool equals(const Base &expected, double tol = 1e-8) const override;
459  static shared_ptr Create(double k, const ReweightScheme reweight = Block);
460  double modelParameter() const { return k_; }
461 
462  private:
463 #ifdef GTSAM_ENABLE_BOOST_SERIALIZATION
464 
465  friend class boost::serialization::access;
466  template <class ARCHIVE>
467  void serialize(ARCHIVE &ar, const unsigned int /*version*/) {
468  ar &BOOST_SERIALIZATION_BASE_OBJECT_NVP(Base);
469  ar &BOOST_SERIALIZATION_NVP(k_);
470  }
471 #endif
472 };
473 
483 class GTSAM_EXPORT AsymmetricTukey : public Base {
484  protected:
485  double c_, csquared_;
486 
487  public:
488  typedef std::shared_ptr<AsymmetricTukey> shared_ptr;
489 
490  AsymmetricTukey(double c = 4.6851, const ReweightScheme reweight = Block);
491  double weight(double distance) const override;
492  double loss(double distance) const override;
493  void print(const std::string &s) const override;
494  bool equals(const Base &expected, double tol = 1e-8) const override;
495  static shared_ptr Create(double k, const ReweightScheme reweight = Block);
496  double modelParameter() const { return c_; }
497 
498  private:
499 #ifdef GTSAM_ENABLE_BOOST_SERIALIZATION
500 
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(Base);
505  ar &BOOST_SERIALIZATION_NVP(c_);
506  }
507 #endif
508 };
509 
519 class GTSAM_EXPORT AsymmetricCauchy : public Base {
520  protected:
521  double k_, ksquared_;
522 
523  public:
524  typedef std::shared_ptr<AsymmetricCauchy> shared_ptr;
525 
526  AsymmetricCauchy(double k = 0.1, const ReweightScheme reweight = Block);
527  double weight(double distance) const override;
528  double loss(double distance) const override;
529  void print(const std::string &s) const override;
530  bool equals(const Base &expected, double tol = 1e-8) const override;
531  static shared_ptr Create(double k, const ReweightScheme reweight = Block);
532  double modelParameter() const { return k_; }
533 
534  private:
535 #ifdef GTSAM_ENABLE_BOOST_SERIALIZATION
536 
537  friend class boost::serialization::access;
538  template <class ARCHIVE>
539  void serialize(ARCHIVE &ar, const unsigned int /*version*/) {
540  ar &BOOST_SERIALIZATION_BASE_OBJECT_NVP(Base);
541  ar &BOOST_SERIALIZATION_NVP(k_);
542  ar &BOOST_SERIALIZATION_NVP(ksquared_);
543  }
544 #endif
545 };
546 
547 // Type alias for the custom loss and weight functions
548 using CustomLossFunction = std::function<double(double)>;
549 using CustomWeightFunction = std::function<double(double)>;
550 
555 class GTSAM_EXPORT Custom : public Base {
556  protected:
557  std::function<double(double)> weight_, loss_;
558  std::string name_;
559 
560  public:
561  typedef std::shared_ptr<Custom> shared_ptr;
562 
564  const ReweightScheme reweight = Block, std::string name = "Custom");
565  double weight(double distance) const override;
566  double loss(double distance) const override;
567  void print(const std::string &s) const override;
568  bool equals(const Base &expected, double tol = 1e-8) const override;
569  static shared_ptr Create(std::function<double(double)> weight, std::function<double(double)> loss,
570  const ReweightScheme reweight = Block, const std::string &name = "Custom");
571  inline std::string& name() { return name_; }
572 
573  inline std::function<double(double)>& weightFunction() { return weight_; }
574  inline std::function<double(double)>& lossFunction() { return loss_; }
575 
576  // Default constructor for serialization
577  inline Custom() = default;
578 
579  private:
580 #ifdef GTSAM_ENABLE_BOOST_SERIALIZATION
581 
582  friend class boost::serialization::access;
583  template <class ARCHIVE>
584  void serialize(ARCHIVE &ar, const unsigned int /*version*/) {
585  ar &BOOST_SERIALIZATION_BASE_OBJECT_NVP(Base);
586  ar &BOOST_SERIALIZATION_NVP(name_);
587  }
588 #endif
589 };
590 
591 } // namespace mEstimator
592 } // namespace noiseModel
593 } // namespace gtsam
gtsam::noiseModel::mEstimator::L2WithDeadZone::modelParameter
double modelParameter() const
Definition: LossFunctions.h:460
gtsam::noiseModel::mEstimator::Fair::c_
double c_
Definition: LossFunctions.h:184
name
Annotation for function names.
Definition: attr.h:51
gtsam::noiseModel::mEstimator::Fair::shared_ptr
std::shared_ptr< Fair > shared_ptr
Definition: LossFunctions.h:187
A3
static const double A3[]
Definition: expn.h:8
s
RealScalar s
Definition: level1_cplx_impl.h:126
e
Array< double, 1, 3 > e(1./3., 0.5, 2.)
gtsam::noiseModel::mEstimator::Tukey
Definition: LossFunctions.h:293
gtsam::noiseModel::mEstimator::CustomLossFunction
std::function< double(double)> CustomLossFunction
Definition: LossFunctions.h:548
Testable.h
Concept check for values that can be used in unit tests.
gtsam::noiseModel::mEstimator::GemanMcClure::shared_ptr
std::shared_ptr< GemanMcClure > shared_ptr
Definition: LossFunctions.h:368
gtsam::noiseModel::mEstimator::GemanMcClure::~GemanMcClure
~GemanMcClure() override
Definition: LossFunctions.h:371
c
Scalar Scalar * c
Definition: benchVecAdd.cpp:17
Matrix.h
typedef and functions to augment Eigen's MatrixXd
gtsam::noiseModel::mEstimator::Null::~Null
~Null() override
Definition: LossFunctions.h:156
gtsam::noiseModel::mEstimator::Cauchy::ksquared_
double ksquared_
Definition: LossFunctions.h:259
gtsam::noiseModel::mEstimator::Fair
Definition: LossFunctions.h:182
gtsam::Matrix
Eigen::MatrixXd Matrix
Definition: base/Matrix.h:39
gtsam::noiseModel::mEstimator::AsymmetricCauchy::ksquared_
double ksquared_
Definition: LossFunctions.h:521
gtsam::Vector
Eigen::VectorXd Vector
Definition: Vector.h:38
gtsam::noiseModel::mEstimator::L2WithDeadZone::shared_ptr
std::shared_ptr< L2WithDeadZone > shared_ptr
Definition: LossFunctions.h:452
gtsam::noiseModel::mEstimator::Huber
Definition: LossFunctions.h:217
gtsam::noiseModel::mEstimator::Base::reweight_
ReweightScheme reweight_
Strategy for reweighting.
Definition: LossFunctions.h:75
gtsam::noiseModel::mEstimator::AsymmetricTukey::shared_ptr
std::shared_ptr< AsymmetricTukey > shared_ptr
Definition: LossFunctions.h:488
gtsam::noiseModel::mEstimator::Welsch::modelParameter
double modelParameter() const
Definition: LossFunctions.h:341
gtsam::noiseModel::mEstimator::Tukey::csquared_
double csquared_
Definition: LossFunctions.h:295
gtsam::noiseModel::mEstimator::Welsch::shared_ptr
std::shared_ptr< Welsch > shared_ptr
Definition: LossFunctions.h:333
gtsam::noiseModel::mEstimator::Base::Scalar
@ Scalar
Definition: LossFunctions.h:70
gtsam::noiseModel::mEstimator::GemanMcClure::c_
double c_
Definition: LossFunctions.h:380
gtsam::noiseModel::mEstimator::Custom::weightFunction
std::function< double(double)> & weightFunction()
Definition: LossFunctions.h:573
gtsam::noiseModel::mEstimator::Null
Definition: LossFunctions.h:151
gtsam::print
void print(const Matrix &A, const string &s, ostream &stream)
Definition: Matrix.cpp:155
gtsam::noiseModel::mEstimator::Base::shared_ptr
std::shared_ptr< Base > shared_ptr
Definition: LossFunctions.h:71
gtsam::noiseModel::mEstimator::Custom::weight_
std::function< double(double)> weight_
Definition: LossFunctions.h:557
A
Definition: test_numpy_dtypes.cpp:298
gtsam::noiseModel::mEstimator::Custom
Definition: LossFunctions.h:555
gtsam::noiseModel::mEstimator::Huber::shared_ptr
std::shared_ptr< Huber > shared_ptr
Definition: LossFunctions.h:222
gtsam::noiseModel::mEstimator::DCS::modelParameter
double modelParameter() const
Definition: LossFunctions.h:417
gtsam::noiseModel::mEstimator::Custom::lossFunction
std::function< double(double)> & lossFunction()
Definition: LossFunctions.h:574
gtsam::noiseModel::mEstimator::Null::shared_ptr
std::shared_ptr< Null > shared_ptr
Definition: LossFunctions.h:153
gtsam::noiseModel::mEstimator::DCS::~DCS
~DCS() override
Definition: LossFunctions.h:411
gtsam::noiseModel::mEstimator::Base::loss
virtual double loss(double distance) const
Definition: LossFunctions.h:97
gtsam::noiseModel::mEstimator::Base::ReweightScheme
ReweightScheme
Definition: LossFunctions.h:70
gtsam::noiseModel::mEstimator::Cauchy
Definition: LossFunctions.h:257
A2
static const double A2[]
Definition: expn.h:7
cholesky::expected
Matrix expected
Definition: testMatrix.cpp:971
gtsam::noiseModel::mEstimator::L2WithDeadZone
Definition: LossFunctions.h:447
gtsam::noiseModel::mEstimator::Null::loss
double loss(double distance) const override
Definition: LossFunctions.h:158
gtsam::noiseModel::mEstimator::Base::reweightScheme
ReweightScheme reweightScheme() const
Returns the reweight scheme, as explained in ReweightScheme.
Definition: LossFunctions.h:82
gtsam::noiseModel::mEstimator::DCS::shared_ptr
std::shared_ptr< DCS > shared_ptr
Definition: LossFunctions.h:408
gtsam::noiseModel::mEstimator::GemanMcClure::modelParameter
double modelParameter() const
Definition: LossFunctions.h:377
gtsam::noiseModel::mEstimator::Tukey::shared_ptr
std::shared_ptr< Tukey > shared_ptr
Definition: LossFunctions.h:298
gtsam::noiseModel::mEstimator::Custom::shared_ptr
std::shared_ptr< Custom > shared_ptr
Definition: LossFunctions.h:561
gtsam::noiseModel::mEstimator::Base::Base
Base(const ReweightScheme reweight=Block)
Definition: LossFunctions.h:78
gtsam::noiseModel::mEstimator::CustomWeightFunction
std::function< double(double)> CustomWeightFunction
Definition: LossFunctions.h:549
gtsam::equals
Definition: Testable.h:112
gtsam::noiseModel::mEstimator::AsymmetricCauchy
Definition: LossFunctions.h:519
gtsam::noiseModel::mEstimator::DCS::c_
double c_
Definition: LossFunctions.h:420
gtsam
traits
Definition: chartTesting.h:28
error
static double error
Definition: testRot3.cpp:37
gtsam::noiseModel::mEstimator::Base::sqrtWeight
double sqrtWeight(double distance) const
Definition: LossFunctions.h:114
gtsam::noiseModel::mEstimator::AsymmetricTukey::modelParameter
double modelParameter() const
Definition: LossFunctions.h:496
A1
static const double A1[]
Definition: expn.h:6
gtsam::noiseModel::mEstimator::Null::equals
bool equals(const Base &, double) const override
Definition: LossFunctions.h:160
gtsam::noiseModel::mEstimator::AsymmetricTukey
Definition: LossFunctions.h:483
gtsam::noiseModel::mEstimator::AsymmetricCauchy::shared_ptr
std::shared_ptr< AsymmetricCauchy > shared_ptr
Definition: LossFunctions.h:524
gtsam::tol
const G double tol
Definition: Group.h:79
gtsam::noiseModel::mEstimator::AsymmetricCauchy::modelParameter
double modelParameter() const
Definition: LossFunctions.h:532
gtsam::noiseModel::mEstimator::Welsch
Definition: LossFunctions.h:328
gtsam::distance
Double_ distance(const OrientedPlane3_ &p)
Definition: slam/expressions.h:117
gtsam::noiseModel::mEstimator::Fair::modelParameter
double modelParameter() const
Definition: LossFunctions.h:195
gtsam::noiseModel::mEstimator::Null::weight
double weight(double) const override
Definition: LossFunctions.h:157
gtsam::noiseModel::mEstimator::L2WithDeadZone::k_
double k_
Definition: LossFunctions.h:449
gtsam::noiseModel::mEstimator::Tukey::modelParameter
double modelParameter() const
Definition: LossFunctions.h:306
gtsam::noiseModel::mEstimator::Huber::k_
double k_
Definition: LossFunctions.h:219
gtsam::noiseModel::mEstimator::Cauchy::shared_ptr
std::shared_ptr< Cauchy > shared_ptr
Definition: LossFunctions.h:262
gtsam::noiseModel::mEstimator::Cauchy::modelParameter
double modelParameter() const
Definition: LossFunctions.h:270
gtsam::noiseModel::mEstimator::Base
Definition: LossFunctions.h:66
gtsam::noiseModel::mEstimator::GemanMcClure
Definition: LossFunctions.h:366
gtsam::noiseModel::mEstimator::Huber::modelParameter
double modelParameter() const
Definition: LossFunctions.h:230
gtsam::noiseModel::mEstimator::Null::Null
Null(const ReweightScheme reweight=Block)
Definition: LossFunctions.h:155
ceres::sqrt
Jet< T, N > sqrt(const Jet< T, N > &f)
Definition: jet.h:418
gtsam::noiseModel::mEstimator::AsymmetricTukey::csquared_
double csquared_
Definition: LossFunctions.h:485
gtsam::noiseModel::mEstimator::DCS
Definition: LossFunctions.h:406
gtsam::noiseModel::mEstimator::Base::~Base
virtual ~Base()
Definition: LossFunctions.h:79
gtsam::noiseModel::mEstimator::Custom::name
std::string & name()
Definition: LossFunctions.h:571
gtsam::noiseModel::mEstimator::Custom::name_
std::string name_
Definition: LossFunctions.h:558
gtsam::noiseModel::mEstimator::Welsch::csquared_
double csquared_
Definition: LossFunctions.h:330


gtsam
Author(s):
autogenerated on Thu Jun 13 2024 03:03:04