diff --git a/internal/ceres/line_search_minimizer.cc b/internal/ceres/line_search_minimizer.cc
index 977fd6c..7623f8d 100644
--- a/internal/ceres/line_search_minimizer.cc
+++ b/internal/ceres/line_search_minimizer.cc
@@ -95,7 +95,8 @@
   }
 
   state->gradient_squared_norm = (x - projected_gradient_step).squaredNorm();
-  state->gradient_max_norm = (x - projected_gradient_step).lpNorm<Eigen::Infinity>();
+  state->gradient_max_norm =
+      (x - projected_gradient_step).lpNorm<Eigen::Infinity>();
   return true;
 }
 
diff --git a/internal/ceres/parameter_block.h b/internal/ceres/parameter_block.h
index c3fcce3..a978eb5 100644
--- a/internal/ceres/parameter_block.h
+++ b/internal/ceres/parameter_block.h
@@ -352,6 +352,10 @@
   // If non-null, contains the residual blocks this parameter block is in.
   scoped_ptr<ResidualBlockSet> residual_blocks_;
 
+  // Upper and lower bounds for the parameter block. These arrays are
+  // initialized to std::numeric_limits<double>::max() and
+  // -std::numeric_limits<double>::max() respectively which correspond
+  // to the parameter block being unconstrained.
   scoped_array<double> upper_bounds_;
   scoped_array<double> lower_bounds_;
 
diff --git a/internal/ceres/solver_impl.cc b/internal/ceres/solver_impl.cc
index 937ab78..a0ad1b7 100644
--- a/internal/ceres/solver_impl.cc
+++ b/internal/ceres/solver_impl.cc
@@ -364,7 +364,8 @@
       for (int j = 0; j < size; ++j) {
         if (array[j] < lower_bounds[j] || array[j] > upper_bounds[j]) {
           *message = StringPrintf(
-              "ParameterBlock: %p with size %d has at least one infeasible value."
+              "ParameterBlock: %p with size %d has at least one infeasible "
+              "value."
               "\nFirst infeasible value is at index: %d."
               "\nLower bound: %e, value: %e, upper bound: %e"
               "\nParameter block values: ",
@@ -380,7 +381,8 @@
       for (int j = 0; j < size; ++j) {
         if (lower_bounds[j] >= upper_bounds[j]) {
           *message = StringPrintf(
-              "ParameterBlock: %p with size %d has at least one infeasible bound."
+              "ParameterBlock: %p with size %d has at least one infeasible "
+              "bound."
               "\nFirst infeasible bound is at index: %d."
               "\nLower bound: %e, upper bound: %e"
               "\nParameter block values: ",
diff --git a/internal/ceres/trust_region_minimizer.cc b/internal/ceres/trust_region_minimizer.cc
index 51eb75f..e2f1234 100644
--- a/internal/ceres/trust_region_minimizer.cc
+++ b/internal/ceres/trust_region_minimizer.cc
@@ -175,7 +175,8 @@
   if (options.is_constrained) {
     delta.setZero();
     if (!evaluator->Plus(x.data(), delta.data(), x_plus_delta.data())) {
-      summary->message = "Unable to project initial point onto the feasible set.";
+      summary->message =
+          "Unable to project initial point onto the feasible set.";
       summary->termination_type = FAILURE;
       LOG_IF(WARNING, is_not_silent) << "Terminating: " << summary->message;
       return;
