diff --git a/include/ceres/loss_function.h b/include/ceres/loss_function.h
index 97a70b6..7aabf7d 100644
--- a/include/ceres/loss_function.h
+++ b/include/ceres/loss_function.h
@@ -1,5 +1,5 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2015 Google Inc. All rights reserved.
+// Copyright 2019 Google Inc. All rights reserved.
 // http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
@@ -76,9 +76,10 @@
 #define CERES_PUBLIC_LOSS_FUNCTION_H_
 
 #include <memory>
-#include "glog/logging.h"
-#include "ceres/types.h"
+
 #include "ceres/internal/disable_warnings.h"
+#include "ceres/types.h"
+#include "glog/logging.h"
 
 namespace ceres {
 
@@ -118,7 +119,6 @@
 // Note: in the region of interest (i.e. s < 3) we have:
 //   TrivialLoss >= HuberLoss >= SoftLOneLoss >= CauchyLoss
 
-
 // This corresponds to no robustification.
 //
 //   rho(s) = s
@@ -130,7 +130,7 @@
 // thing.
 class CERES_EXPORT TrivialLoss : public LossFunction {
  public:
-  virtual void Evaluate(double, double*) const;
+  void Evaluate(double, double*) const override;
 };
 
 // Scaling
@@ -173,8 +173,8 @@
 //   http://en.wikipedia.org/wiki/Huber_Loss_Function
 class CERES_EXPORT HuberLoss : public LossFunction {
  public:
-  explicit HuberLoss(double a) : a_(a), b_(a * a) { }
-  virtual void Evaluate(double, double*) const;
+  explicit HuberLoss(double a) : a_(a), b_(a * a) {}
+  void Evaluate(double, double*) const override;
 
  private:
   const double a_;
@@ -186,11 +186,11 @@
 //
 //   rho(s) = 2 (sqrt(1 + s) - 1).
 //
-// At s = 0: rho = [0, 1, -1/2].
+// At s = 0: rho = [0, 1, -1 / (2 * a^2)].
 class CERES_EXPORT SoftLOneLoss : public LossFunction {
  public:
-  explicit SoftLOneLoss(double a) : b_(a * a), c_(1 / b_) { }
-  virtual void Evaluate(double, double*) const;
+  explicit SoftLOneLoss(double a) : b_(a * a), c_(1 / b_) {}
+  void Evaluate(double, double*) const override;
 
  private:
   // b = a^2.
@@ -203,11 +203,11 @@
 //
 //   rho(s) = log(1 + s).
 //
-// At s = 0: rho = [0, 1, -1].
+// At s = 0: rho = [0, 1, -1 / a^2].
 class CERES_EXPORT CauchyLoss : public LossFunction {
  public:
-  explicit CauchyLoss(double a) : b_(a * a), c_(1 / b_) { }
-  virtual void Evaluate(double, double*) const;
+  explicit CauchyLoss(double a) : b_(a * a), c_(1 / b_) {}
+  void Evaluate(double, double*) const override;
 
  private:
   // b = a^2.
@@ -227,8 +227,8 @@
 // At s = 0: rho = [0, 1, 0].
 class CERES_EXPORT ArctanLoss : public LossFunction {
  public:
-  explicit ArctanLoss(double a) : a_(a), b_(1 / (a * a)) { }
-  virtual void Evaluate(double, double*) const;
+  explicit ArctanLoss(double a) : a_(a), b_(1 / (a * a)) {}
+  void Evaluate(double, double*) const override;
 
  private:
   const double a_;
@@ -267,7 +267,7 @@
 class CERES_EXPORT TolerantLoss : public LossFunction {
  public:
   explicit TolerantLoss(double a, double b);
-  virtual void Evaluate(double, double*) const;
+  void Evaluate(double, double*) const override;
 
  private:
   const double a_, b_, c_;
@@ -276,16 +276,17 @@
 // This is the Tukey biweight loss function which aggressively
 // attempts to suppress large errors.
 //
-// The term is computed as:
+// The term is computed as follows where the equations are scaled by a
+// factor of 2 because the cost function is given by 1/2 rho(s):
 //
-//   rho(s) = a^2 / 6 * (1 - (1 - s / a^2)^3 )   for s <= a^2,
-//   rho(s) = a^2 / 6                            for s >  a^2.
+//   rho(s) = a^2 / 3 * (1 - (1 - s / a^2)^3 )   for s <= a^2,
+//   rho(s) = a^2 / 3                            for s >  a^2.
 //
-// At s = 0: rho = [0, 0.5, -1 / a^2]
+// At s = 0: rho = [0, 1, -2 / a^2]
 class CERES_EXPORT TukeyLoss : public ceres::LossFunction {
  public:
-  explicit TukeyLoss(double a) : a_squared_(a * a) { }
-  virtual void Evaluate(double, double*) const;
+  explicit TukeyLoss(double a) : a_squared_(a * a) {}
+  void Evaluate(double, double*) const override;
 
  private:
   const double a_squared_;
@@ -296,10 +297,12 @@
 // The loss functions must not be NULL.
 class CERES_EXPORT ComposedLoss : public LossFunction {
  public:
-  explicit ComposedLoss(const LossFunction* f, Ownership ownership_f,
-                        const LossFunction* g, Ownership ownership_g);
+  explicit ComposedLoss(const LossFunction* f,
+                        Ownership ownership_f,
+                        const LossFunction* g,
+                        Ownership ownership_g);
   virtual ~ComposedLoss();
-  virtual void Evaluate(double, double*) const;
+  void Evaluate(double, double*) const override;
 
  private:
   std::unique_ptr<const LossFunction> f_, g_;
@@ -328,8 +331,8 @@
   // Constructs a ScaledLoss wrapping another loss function. Takes
   // ownership of the wrapped loss function or not depending on the
   // ownership parameter.
-  ScaledLoss(const LossFunction* rho, double a, Ownership ownership) :
-      rho_(rho), a_(a), ownership_(ownership) { }
+  ScaledLoss(const LossFunction* rho, double a, Ownership ownership)
+      : rho_(rho), a_(a), ownership_(ownership) {}
   ScaledLoss(const ScaledLoss&) = delete;
   void operator=(const ScaledLoss&) = delete;
 
@@ -338,7 +341,7 @@
       rho_.release();
     }
   }
-  virtual void Evaluate(double, double*) const;
+  void Evaluate(double, double*) const override;
 
  private:
   std::unique_ptr<const LossFunction> rho_;
@@ -387,8 +390,7 @@
 class CERES_EXPORT LossFunctionWrapper : public LossFunction {
  public:
   LossFunctionWrapper(LossFunction* rho, Ownership ownership)
-      : rho_(rho), ownership_(ownership) {
-  }
+      : rho_(rho), ownership_(ownership) {}
 
   LossFunctionWrapper(const LossFunctionWrapper&) = delete;
   void operator=(const LossFunctionWrapper&) = delete;
@@ -399,13 +401,12 @@
     }
   }
 
-  virtual void Evaluate(double sq_norm, double out[3]) const {
+  void Evaluate(double sq_norm, double out[3]) const override {
     if (rho_.get() == NULL) {
       out[0] = sq_norm;
       out[1] = 1.0;
       out[2] = 0.0;
-    }
-    else {
+    } else {
       rho_->Evaluate(sq_norm, out);
     }
   }