diff --git a/examples/nist.cc b/examples/nist.cc
index 8c91a29..244a7f8 100644
--- a/examples/nist.cc
+++ b/examples/nist.cc
@@ -124,10 +124,17 @@
 typedef Eigen::Matrix<double, Dynamic, 1> Vector;
 typedef Eigen::Matrix<double, Dynamic, Dynamic, RowMajor> Matrix;
 
+using std::ifstream;
+using std::vector;
+using std::string;
+using std::atoi;
+using std::atof;
+using std::cout;
+
 void SplitStringUsingChar(const string& full,
                           const char delim,
                           vector<string>* result) {
-  back_insert_iterator< vector<string> > it(*result);
+  std::back_insert_iterator< vector<string> > it(*result);
 
   const char* p = full.data();
   const char* end = p + full.size();
@@ -144,15 +151,15 @@
   }
 }
 
-bool GetAndSplitLine(std::ifstream& ifs, std::vector<std::string>* pieces) {
+bool GetAndSplitLine(ifstream& ifs, vector<string>* pieces) {
   pieces->clear();
   char buf[256];
   ifs.getline(buf, 256);
-  SplitStringUsingChar(std::string(buf), ' ', pieces);
+  SplitStringUsingChar(string(buf), ' ', pieces);
   return true;
 }
 
-void SkipLines(std::ifstream& ifs, int num_lines) {
+void SkipLines(ifstream& ifs, int num_lines) {
   char buf[256];
   for (int i = 0; i < num_lines; ++i) {
     ifs.getline(buf, 256);
@@ -161,23 +168,23 @@
 
 class NISTProblem {
  public:
-  explicit NISTProblem(const std::string& filename) {
-    std::ifstream ifs(filename.c_str(), std::ifstream::in);
+  explicit NISTProblem(const string& filename) {
+    ifstream ifs(filename.c_str(), ifstream::in);
 
-    std::vector<std::string> pieces;
+    vector<string> pieces;
     SkipLines(ifs, 24);
     GetAndSplitLine(ifs, &pieces);
-    const int kNumResponses = std::atoi(pieces[1].c_str());
+    const int kNumResponses = atoi(pieces[1].c_str());
 
     GetAndSplitLine(ifs, &pieces);
-    const int kNumPredictors = std::atoi(pieces[0].c_str());
+    const int kNumPredictors = atoi(pieces[0].c_str());
 
     GetAndSplitLine(ifs, &pieces);
-    const int kNumObservations = std::atoi(pieces[0].c_str());
+    const int kNumObservations = atoi(pieces[0].c_str());
 
     SkipLines(ifs, 4);
     GetAndSplitLine(ifs, &pieces);
-    const int kNumParameters = std::atoi(pieces[0].c_str());
+    const int kNumParameters = atoi(pieces[0].c_str());
     SkipLines(ifs, 8);
 
     // Get the first line of initial and final parameter values to
@@ -193,24 +200,24 @@
     // Parse the line for parameter b1.
     int parameter_id = 0;
     for (int i = 0; i < kNumTries; ++i) {
-      initial_parameters_(i, parameter_id) = std::atof(pieces[i + 2].c_str());
+      initial_parameters_(i, parameter_id) = atof(pieces[i + 2].c_str());
     }
-    final_parameters_(0, parameter_id) = std::atof(pieces[2 + kNumTries].c_str());
+    final_parameters_(0, parameter_id) = atof(pieces[2 + kNumTries].c_str());
 
     // Parse the remaining parameter lines.
     for (int parameter_id = 1; parameter_id < kNumParameters; ++parameter_id) {
      GetAndSplitLine(ifs, &pieces);
      // b2, b3, ....
      for (int i = 0; i < kNumTries; ++i) {
-       initial_parameters_(i, parameter_id) = std::atof(pieces[i + 2].c_str());
+       initial_parameters_(i, parameter_id) = atof(pieces[i + 2].c_str());
      }
-     final_parameters_(0, parameter_id) = std::atof(pieces[2 + kNumTries].c_str());
+     final_parameters_(0, parameter_id) = atof(pieces[2 + kNumTries].c_str());
     }
 
     // Certfied cost
     SkipLines(ifs, 1);
     GetAndSplitLine(ifs, &pieces);
-    certified_cost_ = std::atof(pieces[4].c_str()) / 2.0;
+    certified_cost_ = atof(pieces[4].c_str()) / 2.0;
 
     // Read the observations.
     SkipLines(ifs, 18 - kNumParameters);
@@ -218,12 +225,12 @@
       GetAndSplitLine(ifs, &pieces);
       // Response.
       for (int j = 0; j < kNumResponses; ++j) {
-        response_(i, j) =  std::atof(pieces[j].c_str());
+        response_(i, j) =  atof(pieces[j].c_str());
       }
 
       // Predictor variables.
       for (int j = 0; j < kNumPredictors; ++j) {
-        predictor_(i, j) =  std::atof(pieces[j + kNumResponses].c_str());
+        predictor_(i, j) =  atof(pieces[j + kNumResponses].c_str());
       }
     }
   }
@@ -404,7 +411,7 @@
 };
 
 template <typename Model, int num_residuals, int num_parameters>
-int RegressionDriver(const std::string& filename,
+int RegressionDriver(const string& filename,
                      const ceres::Solver::Options& options) {
   NISTProblem nist_problem(FLAGS_nist_data_dir + filename);
   CHECK_EQ(num_residuals, nist_problem.response_size());
@@ -518,7 +525,7 @@
   ceres::Solver::Options options;
   SetMinimizerOptions(&options);
 
-  std::cout << "Lower Difficulty\n";
+  cout << "Lower Difficulty\n";
   int easy_success = 0;
   easy_success += RegressionDriver<Misra1a,  1, 2>("Misra1a.dat",  options);
   easy_success += RegressionDriver<Chwirut,  1, 3>("Chwirut1.dat", options);
@@ -529,7 +536,7 @@
   easy_success += RegressionDriver<DanWood,  1, 2>("DanWood.dat",  options);
   easy_success += RegressionDriver<Misra1b,  1, 2>("Misra1b.dat",  options);
 
-  std::cout << "\nMedium Difficulty\n";
+  cout << "\nMedium Difficulty\n";
   int medium_success = 0;
   medium_success += RegressionDriver<Kirby2,   1, 5>("Kirby2.dat",   options);
   medium_success += RegressionDriver<Hahn1,    1, 7>("Hahn1.dat",    options);
@@ -543,7 +550,7 @@
   medium_success += RegressionDriver<Roszman1, 1, 4>("Roszman1.dat", options);
   medium_success += RegressionDriver<ENSO,     1, 9>("ENSO.dat",     options);
 
-  std::cout << "\nHigher Difficulty\n";
+  cout << "\nHigher Difficulty\n";
   int hard_success = 0;
   hard_success += RegressionDriver<MGH09,    1, 4>("MGH09.dat",    options);
   hard_success += RegressionDriver<Thurber,  1, 7>("Thurber.dat",  options);
@@ -555,11 +562,11 @@
   hard_success += RegressionDriver<Rat43,    1, 4>("Rat43.dat",    options);
   hard_success += RegressionDriver<Bennet5,  1, 3>("Bennett5.dat", options);
 
-  std::cout << "\n";
-  std::cout << "Easy    : " << easy_success << "/16\n";
-  std::cout << "Medium  : " << medium_success << "/22\n";
-  std::cout << "Hard    : " << hard_success << "/16\n";
-  std::cout << "Total   : " << easy_success + medium_success + hard_success << "/54\n";
+  cout << "\n";
+  cout << "Easy    : " << easy_success << "/16\n";
+  cout << "Medium  : " << medium_success << "/22\n";
+  cout << "Hard    : " << hard_success << "/16\n";
+  cout << "Total   : " << easy_success + medium_success + hard_success << "/54\n";
 }
 
 }  // namespace examples
diff --git a/include/ceres/conditioned_cost_function.h b/include/ceres/conditioned_cost_function.h
index 3f0087c..eee7116 100644
--- a/include/ceres/conditioned_cost_function.h
+++ b/include/ceres/conditioned_cost_function.h
@@ -78,7 +78,7 @@
   // functions, or not, depending on the ownership parameter. Conditioners
   // may be NULL, in which case the corresponding residual is not modified.
   ConditionedCostFunction(CostFunction* wrapped_cost_function,
-                          const vector<CostFunction*>& conditioners,
+                          const std::vector<CostFunction*>& conditioners,
                           Ownership ownership);
   virtual ~ConditionedCostFunction();
 
@@ -88,7 +88,7 @@
 
  private:
   internal::scoped_ptr<CostFunction> wrapped_cost_function_;
-  vector<CostFunction*> conditioners_;
+  std::vector<CostFunction*> conditioners_;
   Ownership ownership_;
 };
 
diff --git a/include/ceres/cost_function.h b/include/ceres/cost_function.h
index fe8fc07..069e572 100644
--- a/include/ceres/cost_function.h
+++ b/include/ceres/cost_function.h
@@ -115,7 +115,7 @@
                         double* residuals,
                         double** jacobians) const = 0;
 
-  const vector<int32>& parameter_block_sizes() const {
+  const std::vector<int32>& parameter_block_sizes() const {
     return parameter_block_sizes_;
   }
 
@@ -124,7 +124,7 @@
   }
 
  protected:
-  vector<int32>* mutable_parameter_block_sizes() {
+  std::vector<int32>* mutable_parameter_block_sizes() {
     return &parameter_block_sizes_;
   }
 
@@ -135,7 +135,7 @@
  private:
   // Cost function signature metadata: number of inputs & their sizes,
   // number of outputs (residuals).
-  vector<int32> parameter_block_sizes_;
+  std::vector<int32> parameter_block_sizes_;
   int num_residuals_;
   CERES_DISALLOW_COPY_AND_ASSIGN(CostFunction);
 };
diff --git a/include/ceres/cost_function_to_functor.h b/include/ceres/cost_function_to_functor.h
index b4a516e..65bc931 100644
--- a/include/ceres/cost_function_to_functor.h
+++ b/include/ceres/cost_function_to_functor.h
@@ -112,20 +112,20 @@
     // This block breaks the 80 column rule to keep it somewhat readable.
     CHECK((!N1 && !N2 && !N3 && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) ||
           ((N1 > 0) && !N2 && !N3 && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) ||
-          ((N1 > 0) && (N2 > 0) && !N3 && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) ||
-          ((N1 > 0) && (N2 > 0) && (N3 > 0) && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) ||
-          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && !N5 && !N6 && !N7 && !N8 && !N9) ||
-          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && !N6 && !N7 && !N8 && !N9) ||
-          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && !N7 && !N8 && !N9) ||
-          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && !N8 && !N9) ||
-          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && (N8 > 0) && !N9) ||
-          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && (N8 > 0) && (N9 > 0)))
+          ((N1 > 0) && (N2 > 0) && !N3 && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) ||                                    // NOLINT
+          ((N1 > 0) && (N2 > 0) && (N3 > 0) && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) ||                               // NOLINT
+          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && !N5 && !N6 && !N7 && !N8 && !N9) ||                          // NOLINT
+          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && !N6 && !N7 && !N8 && !N9) ||                     // NOLINT
+          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && !N7 && !N8 && !N9) ||                // NOLINT
+          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && !N8 && !N9) ||           // NOLINT
+          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && (N8 > 0) && !N9) ||      // NOLINT
+          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && (N8 > 0) && (N9 > 0)))   // NOLINT
         << "Zero block cannot precede a non-zero block. Block sizes are "
         << "(ignore trailing 0s): " << N0 << ", " << N1 << ", " << N2 << ", "
         << N3 << ", " << N4 << ", " << N5 << ", " << N6 << ", " << N7 << ", "
         << N8 << ", " << N9;
 
-    const vector<int32>& parameter_block_sizes =
+    const std::vector<int32>& parameter_block_sizes =
         cost_function->parameter_block_sizes();
     const int num_parameter_blocks =
         (N0 > 0) + (N1 > 0) + (N2 > 0) + (N3 > 0) + (N4 > 0) +
@@ -677,7 +677,7 @@
   template <typename JetT>
   bool EvaluateWithJets(const JetT** inputs, JetT* output) const {
     const int kNumParameters =  N0 + N1 + N2 + N3 + N4 + N5 + N6 + N7 + N8 + N9;
-    const vector<int32>& parameter_block_sizes =
+    const std::vector<int32>& parameter_block_sizes =
         cost_function_->parameter_block_sizes();
     const int num_parameter_blocks = parameter_block_sizes.size();
     const int num_residuals = cost_function_->num_residuals();
diff --git a/include/ceres/covariance.h b/include/ceres/covariance.h
index 35fde4d..1966340 100644
--- a/include/ceres/covariance.h
+++ b/include/ceres/covariance.h
@@ -183,7 +183,7 @@
 //  Covariance::Options options;
 //  Covariance covariance(options);
 //
-//  vector<pair<const double*, const double*> > covariance_blocks;
+//  std::vector<std::pair<const double*, const double*> > covariance_blocks;
 //  covariance_blocks.push_back(make_pair(x, x));
 //  covariance_blocks.push_back(make_pair(y, y));
 //  covariance_blocks.push_back(make_pair(x, y));
@@ -353,7 +353,8 @@
   // Covariance::Options for more on the conditions under which this
   // function returns false.
   bool Compute(
-      const vector<pair<const double*, const double*> >& covariance_blocks,
+      const std::vector<std::pair<const double*,
+                                  const double*> >& covariance_blocks,
       Problem* problem);
 
   // Return the block of the covariance matrix corresponding to
diff --git a/include/ceres/crs_matrix.h b/include/ceres/crs_matrix.h
index d2d6289..757cac3 100644
--- a/include/ceres/crs_matrix.h
+++ b/include/ceres/crs_matrix.h
@@ -74,9 +74,9 @@
   //  cols   = [ 1,  3,  1,  2,  3,  0,  1]
   //  values = [10,  4,  2, -3,  2,  1,  2]
 
-  vector<int> cols;
-  vector<int> rows;
-  vector<double> values;
+  std::vector<int> cols;
+  std::vector<int> rows;
+  std::vector<double> values;
 };
 
 }  // namespace ceres
diff --git a/include/ceres/dynamic_autodiff_cost_function.h b/include/ceres/dynamic_autodiff_cost_function.h
index f9342cd..810aded 100644
--- a/include/ceres/dynamic_autodiff_cost_function.h
+++ b/include/ceres/dynamic_autodiff_cost_function.h
@@ -120,18 +120,18 @@
                                                0);
 
     // Allocate scratch space for the strided evaluation.
-    vector<Jet<double, Stride> > input_jets(num_parameters);
-    vector<Jet<double, Stride> > output_jets(num_residuals());
+    std::vector<Jet<double, Stride> > input_jets(num_parameters);
+    std::vector<Jet<double, Stride> > output_jets(num_residuals());
 
     // Make the parameter pack that is sent to the functor (reused).
-    vector<Jet<double, Stride>* > jet_parameters(num_parameter_blocks,
+    std::vector<Jet<double, Stride>* > jet_parameters(num_parameter_blocks,
         static_cast<Jet<double, Stride>* >(NULL));
     int num_active_parameters = 0;
 
     // To handle constant parameters between non-constant parameter blocks, the
     // start position --- a raw parameter index --- of each contiguous block of
     // non-constant parameters is recorded in start_derivative_section.
-    vector<int> start_derivative_section;
+    std::vector<int> start_derivative_section;
     bool in_derivative_section = false;
     int parameter_cursor = 0;
 
diff --git a/include/ceres/dynamic_numeric_diff_cost_function.h b/include/ceres/dynamic_numeric_diff_cost_function.h
index 2b6e826..37a1eb6 100644
--- a/include/ceres/dynamic_numeric_diff_cost_function.h
+++ b/include/ceres/dynamic_numeric_diff_cost_function.h
@@ -104,7 +104,7 @@
         << "You must call DynamicNumericDiffCostFunction::SetNumResiduals() "
         << "before DynamicNumericDiffCostFunction::Evaluate().";
 
-    const vector<int32>& block_sizes = parameter_block_sizes();
+    const std::vector<int32>& block_sizes = parameter_block_sizes();
     CHECK(!block_sizes.empty())
         << "You must call DynamicNumericDiffCostFunction::AddParameterBlock() "
         << "before DynamicNumericDiffCostFunction::Evaluate().";
@@ -116,8 +116,8 @@
 
     // Create local space for a copy of the parameters which will get mutated.
     int parameters_size = accumulate(block_sizes.begin(), block_sizes.end(), 0);
-    vector<double> parameters_copy(parameters_size);
-    vector<double*> parameters_references_copy(block_sizes.size());
+    std::vector<double> parameters_copy(parameters_size);
+    std::vector<double*> parameters_references_copy(block_sizes.size());
     parameters_references_copy[0] = &parameters_copy[0];
     for (int block = 1; block < block_sizes.size(); ++block) {
       parameters_references_copy[block] = parameters_references_copy[block - 1]
diff --git a/include/ceres/fpclassify.h b/include/ceres/fpclassify.h
index da8a4d0..c2afeab 100644
--- a/include/ceres/fpclassify.h
+++ b/include/ceres/fpclassify.h
@@ -50,7 +50,7 @@
 inline bool IsFinite  (double x) { return _finite(x) != 0;                   }
 inline bool IsInfinite(double x) { return _finite(x) == 0 && _isnan(x) == 0; }
 inline bool IsNaN     (double x) { return _isnan(x) != 0;                    }
-inline bool IsNormal  (double x) {
+inline bool IsNormal  (double x) {  // NOLINT
   int classification = _fpclass(x);
   return classification == _FPCLASS_NN ||
          classification == _FPCLASS_PN;
diff --git a/include/ceres/gradient_checker.h b/include/ceres/gradient_checker.h
index 79ebae5..72b05b6 100644
--- a/include/ceres/gradient_checker.h
+++ b/include/ceres/gradient_checker.h
@@ -78,10 +78,10 @@
     // block.
 
     // Derivatives as computed by the cost function.
-    vector<Matrix> term_jacobians;
+    std::vector<Matrix> term_jacobians;
 
     // Derivatives as computed by finite differencing.
-    vector<Matrix> finite_difference_jacobians;
+    std::vector<Matrix> finite_difference_jacobians;
 
     // Infinity-norm of term_jacobians - finite_difference_jacobians.
     double error_jacobians;
@@ -119,7 +119,7 @@
     // Do a consistency check between the term and the template parameters.
     CHECK_EQ(M, term->num_residuals());
     const int num_residuals = M;
-    const vector<int32>& block_sizes = term->parameter_block_sizes();
+    const std::vector<int32>& block_sizes = term->parameter_block_sizes();
     const int num_blocks = block_sizes.size();
 
     CHECK_LE(num_blocks, 5) << "Unable to test functions that take more "
diff --git a/include/ceres/gradient_problem_solver.h b/include/ceres/gradient_problem_solver.h
index 6e16dd7..0676d92 100644
--- a/include/ceres/gradient_problem_solver.h
+++ b/include/ceres/gradient_problem_solver.h
@@ -261,7 +261,7 @@
     // executed, then set update_state_every_iteration to true.
     //
     // The solver does NOT take ownership of these pointers.
-    vector<IterationCallback*> callbacks;
+    std::vector<IterationCallback*> callbacks;
   };
 
   struct CERES_EXPORT Summary {
@@ -292,7 +292,7 @@
     double final_cost;
 
     // IterationSummary for each minimizer iteration in order.
-    vector<IterationSummary> iterations;
+    std::vector<IterationSummary> iterations;
 
     // Sum total of all time spent inside Ceres when Solve is called.
     double total_time_in_seconds;
diff --git a/include/ceres/internal/autodiff.h b/include/ceres/internal/autodiff.h
index 3a96625..ef05d55 100644
--- a/include/ceres/internal/autodiff.h
+++ b/include/ceres/internal/autodiff.h
@@ -214,15 +214,15 @@
     // This block breaks the 80 column rule to keep it somewhat readable.
     DCHECK_GT(num_outputs, 0);
     DCHECK((!N1 && !N2 && !N3 && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) ||
-          ((N1 > 0) && !N2 && !N3 && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) ||
-          ((N1 > 0) && (N2 > 0) && !N3 && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) ||
-          ((N1 > 0) && (N2 > 0) && (N3 > 0) && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) ||
-          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && !N5 && !N6 && !N7 && !N8 && !N9) ||
-          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && !N6 && !N7 && !N8 && !N9) ||
-          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && !N7 && !N8 && !N9) ||
-          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && !N8 && !N9) ||
-          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && (N8 > 0) && !N9) ||
-          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && (N8 > 0) && (N9 > 0)))
+           ((N1 > 0) && !N2 && !N3 && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) ||
+           ((N1 > 0) && (N2 > 0) && !N3 && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) ||                                   // NOLINT
+           ((N1 > 0) && (N2 > 0) && (N3 > 0) && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) ||                              // NOLINT
+           ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && !N5 && !N6 && !N7 && !N8 && !N9) ||                         // NOLINT
+           ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && !N6 && !N7 && !N8 && !N9) ||                    // NOLINT
+           ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && !N7 && !N8 && !N9) ||               // NOLINT
+           ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && !N8 && !N9) ||          // NOLINT
+           ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && (N8 > 0) && !N9) ||     // NOLINT
+           ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && (N8 > 0) && (N9 > 0)))  // NOLINT
         << "Zero block cannot precede a non-zero block. Block sizes are "
         << "(ignore trailing 0s): " << N0 << ", " << N1 << ", " << N2 << ", "
         << N3 << ", " << N4 << ", " << N5 << ", " << N6 << ", " << N7 << ", "
diff --git a/include/ceres/internal/port.h b/include/ceres/internal/port.h
index e38eb71..24eca05 100644
--- a/include/ceres/internal/port.h
+++ b/include/ceres/internal/port.h
@@ -46,12 +46,6 @@
 
 namespace ceres {
 
-// It is unfortunate that this import of the entire standard namespace is
-// necessary. The reasons are historical and won't be explained here, but
-// suffice to say it is not a mistake and can't be removed without breaking
-// things outside of the Ceres optimization package.
-using namespace std;
-
 // This is necessary to properly handle the case that there is a different
 // "string" implementation in the global namespace.
 using std::string;
diff --git a/include/ceres/local_parameterization.h b/include/ceres/local_parameterization.h
index 656c4d4..6a5a689 100644
--- a/include/ceres/local_parameterization.h
+++ b/include/ceres/local_parameterization.h
@@ -173,7 +173,7 @@
 class CERES_EXPORT SubsetParameterization : public LocalParameterization {
  public:
   explicit SubsetParameterization(int size,
-                                  const vector<int>& constant_parameters);
+                                  const std::vector<int>& constant_parameters);
   virtual ~SubsetParameterization() {}
   virtual bool Plus(const double* x,
                     const double* delta,
@@ -191,7 +191,7 @@
 
  private:
   const int local_size_;
-  vector<int> constancy_mask_;
+  std::vector<int> constancy_mask_;
 };
 
 // Plus(x, delta) = [cos(|delta|), sin(|delta|) delta / |delta|] * x
diff --git a/include/ceres/ordered_groups.h b/include/ceres/ordered_groups.h
index c316d71..d42e285 100644
--- a/include/ceres/ordered_groups.h
+++ b/include/ceres/ordered_groups.h
@@ -63,7 +63,8 @@
       return false;
     }
 
-    typename map<T, int>::const_iterator it = element_to_group_.find(element);
+    typename std::map<T, int>::const_iterator it =
+        element_to_group_.find(element);
     if (it != element_to_group_.end()) {
       if (it->second == group) {
         // Element is already in the right group, nothing to do.
@@ -107,7 +108,7 @@
 
   // Bulk remove elements. The return value indicates the number of
   // elements successfully removed.
-  int Remove(const vector<T>& elements) {
+  int Remove(const std::vector<T>& elements) {
     if (NumElements() == 0 || elements.size() == 0) {
       return 0;
     }
@@ -121,14 +122,14 @@
 
   // Reverse the order of the groups in place.
   void Reverse() {
-    typename map<int, set<T> >::reverse_iterator it =
+    typename std::map<int, std::set<T> >::reverse_iterator it =
         group_to_elements_.rbegin();
-    map<int, set<T> > new_group_to_elements;
+    std::map<int, std::set<T> > new_group_to_elements;
     new_group_to_elements[it->first] = it->second;
 
     int new_group_id = it->first + 1;
     for (++it; it != group_to_elements_.rend(); ++it) {
-      for (typename set<T>::const_iterator element_it = it->second.begin();
+      for (typename std::set<T>::const_iterator element_it = it->second.begin();
            element_it != it->second.end();
            ++element_it) {
         element_to_group_[*element_it] = new_group_id;
@@ -143,7 +144,8 @@
   // Return the group id for the element. If the element is not a
   // member of any group, return -1.
   int GroupId(const T element) const {
-    typename map<T, int>::const_iterator it = element_to_group_.find(element);
+    typename std::map<T, int>::const_iterator it =
+        element_to_group_.find(element);
     if (it == element_to_group_.end()) {
       return -1;
     }
@@ -151,14 +153,15 @@
   }
 
   bool IsMember(const T element) const {
-    typename map<T, int>::const_iterator it = element_to_group_.find(element);
+    typename std::map<T, int>::const_iterator it =
+        element_to_group_.find(element);
     return (it != element_to_group_.end());
   }
 
   // This function always succeeds, i.e., implicitly there exists a
   // group for every integer.
   int GroupSize(const int group) const {
-    typename map<int, set<T> >::const_iterator it =
+    typename std::map<int, std::set<T> >::const_iterator it =
         group_to_elements_.find(group);
     return (it ==  group_to_elements_.end()) ? 0 : it->second.size();
   }
@@ -180,17 +183,17 @@
     return group_to_elements_.begin()->first;
   }
 
-  const map<int, set<T> >& group_to_elements() const {
+  const std::map<int, std::set<T> >& group_to_elements() const {
     return group_to_elements_;
   }
 
-  const map<T, int>& element_to_group() const {
+  const std::map<T, int>& element_to_group() const {
     return element_to_group_;
   }
 
  private:
-  map<int, set<T> > group_to_elements_;
-  map<T, int> element_to_group_;
+  std::map<int, std::set<T> > group_to_elements_;
+  std::map<T, int> element_to_group_;
 };
 
 // Typedef for the most commonly used version of OrderedGroups.
diff --git a/include/ceres/problem.h b/include/ceres/problem.h
index be2ac6c..fba120b 100644
--- a/include/ceres/problem.h
+++ b/include/ceres/problem.h
@@ -211,9 +211,10 @@
   //   problem.AddResidualBlock(new MyUnaryCostFunction(...), NULL, x1);
   //   problem.AddResidualBlock(new MyBinaryCostFunction(...), NULL, x2, x1);
   //
-  ResidualBlockId AddResidualBlock(CostFunction* cost_function,
-                                   LossFunction* loss_function,
-                                   const vector<double*>& parameter_blocks);
+  ResidualBlockId AddResidualBlock(
+      CostFunction* cost_function,
+      LossFunction* loss_function,
+      const std::vector<double*>& parameter_blocks);
 
   // Convenience methods for adding residuals with a small number of
   // parameters. This is the common case. Instead of specifying the
@@ -356,17 +357,17 @@
   // Fills the passed parameter_blocks vector with pointers to the
   // parameter blocks currently in the problem. After this call,
   // parameter_block.size() == NumParameterBlocks.
-  void GetParameterBlocks(vector<double*>* parameter_blocks) const;
+  void GetParameterBlocks(std::vector<double*>* parameter_blocks) const;
 
   // Fills the passed residual_blocks vector with pointers to the
   // residual blocks currently in the problem. After this call,
   // residual_blocks.size() == NumResidualBlocks.
-  void GetResidualBlocks(vector<ResidualBlockId>* residual_blocks) const;
+  void GetResidualBlocks(std::vector<ResidualBlockId>* residual_blocks) const;
 
   // Get all the parameter blocks that depend on the given residual block.
   void GetParameterBlocksForResidualBlock(
       const ResidualBlockId residual_block,
-      vector<double*>* parameter_blocks) const;
+      std::vector<double*>* parameter_blocks) const;
 
   // Get the CostFunction for the given residual block.
   const CostFunction* GetCostFunctionForResidualBlock(
@@ -385,7 +386,7 @@
   // block will incur a scan of the entire Problem object.
   void GetResidualBlocksForParameterBlock(
       const double* values,
-      vector<ResidualBlockId>* residual_blocks) const;
+      std::vector<ResidualBlockId>* residual_blocks) const;
 
   // Options struct to control Problem::Evaluate.
   struct EvaluateOptions {
@@ -408,7 +409,7 @@
     // used to add parameter blocks to the Problem. These parameter
     // block should NOT point to new memory locations. Bad things will
     // happen otherwise.
-    vector<double*> parameter_blocks;
+    std::vector<double*> parameter_blocks;
 
     // The set of residual blocks to evaluate. This vector determines
     // the order in which the residuals occur, and how the rows of the
@@ -418,7 +419,7 @@
     // the order in which they were added to the problem. But, this
     // may change if the user removes any residual blocks from the
     // problem.
-    vector<ResidualBlockId> residual_blocks;
+    std::vector<ResidualBlockId> residual_blocks;
 
     // Even though the residual blocks in the problem may contain loss
     // functions, setting apply_loss_function to false will turn off
@@ -462,8 +463,8 @@
   // columns in the jacobian).
   bool Evaluate(const EvaluateOptions& options,
                 double* cost,
-                vector<double>* residuals,
-                vector<double>* gradient,
+                std::vector<double>* residuals,
+                std::vector<double>* gradient,
                 CRSMatrix* jacobian);
 
  private:
diff --git a/include/ceres/rotation.h b/include/ceres/rotation.h
index d77ce21..b7cb32e 100644
--- a/include/ceres/rotation.h
+++ b/include/ceres/rotation.h
@@ -47,6 +47,7 @@
 
 #include <algorithm>
 #include <cmath>
+#include <limits>
 #include "glog/logging.h"
 
 namespace ceres {
diff --git a/include/ceres/sized_cost_function.h b/include/ceres/sized_cost_function.h
index 4f98d4e..0a4325b 100644
--- a/include/ceres/sized_cost_function.h
+++ b/include/ceres/sized_cost_function.h
@@ -55,15 +55,15 @@
 
     // This block breaks the 80 column rule to keep it somewhat readable.
     CHECK((!N1 && !N2 && !N3 && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) ||
-           ((N1 > 0) && !N2 && !N3 && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) ||
-           ((N1 > 0) && (N2 > 0) && !N3 && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) ||
-           ((N1 > 0) && (N2 > 0) && (N3 > 0) && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) ||
-           ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && !N5 && !N6 && !N7 && !N8 && !N9) ||
-           ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && !N6 && !N7 && !N8 && !N9) ||
-           ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && !N7 && !N8 && !N9) ||
-           ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && !N8 && !N9) ||
-           ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && (N8 > 0) && !N9) ||
-           ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && (N8 > 0) && (N9 > 0)))
+          ((N1 > 0) && !N2 && !N3 && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) ||
+          ((N1 > 0) && (N2 > 0) && !N3 && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) ||                                   // NOLINT
+          ((N1 > 0) && (N2 > 0) && (N3 > 0) && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) ||                              // NOLINT
+          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && !N5 && !N6 && !N7 && !N8 && !N9) ||                         // NOLINT
+          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && !N6 && !N7 && !N8 && !N9) ||                    // NOLINT
+          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && !N7 && !N8 && !N9) ||               // NOLINT
+          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && !N8 && !N9) ||          // NOLINT
+          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && (N8 > 0) && !N9) ||     // NOLINT
+          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && (N8 > 0) && (N9 > 0)))  // NOLINT
         << "Zero block cannot precede a non-zero block. Block sizes are "
         << "(ignore trailing 0s): " << N0 << ", " << N1 << ", " << N2 << ", "
         << N3 << ", " << N4 << ", " << N5 << ", " << N6 << ", " << N7 << ", "
diff --git a/include/ceres/solver.h b/include/ceres/solver.h
index b2fa3ae..dc06151 100644
--- a/include/ceres/solver.h
+++ b/include/ceres/solver.h
@@ -92,7 +92,7 @@
       gradient_tolerance = 1e-10;
       parameter_tolerance = 1e-8;
 
-#if defined(CERES_NO_SUITESPARSE) && defined(CERES_NO_CXSPARSE) && !defined(CERES_ENABLE_LGPL_CODE)
+#if defined(CERES_NO_SUITESPARSE) && defined(CERES_NO_CXSPARSE) && !defined(CERES_ENABLE_LGPL_CODE)  // NOLINT
       linear_solver_type = DENSE_QR;
 #else
       linear_solver_type = SPARSE_NORMAL_CHOLESKY;
@@ -677,7 +677,7 @@
     // List of iterations at which the minimizer should dump the trust
     // region problem. Useful for testing and benchmarking. If empty
     // (default), no problems are dumped.
-    vector<int> trust_region_minimizer_iterations_to_dump;
+    std::vector<int> trust_region_minimizer_iterations_to_dump;
 
     // Directory to which the problems should be written to. Should be
     // non-empty if trust_region_minimizer_iterations_to_dump is
@@ -747,7 +747,7 @@
     // executed, then set update_state_every_iteration to true.
     //
     // The solver does NOT take ownership of these pointers.
-    vector<IterationCallback*> callbacks;
+    std::vector<IterationCallback*> callbacks;
   };
 
   struct CERES_EXPORT Summary {
@@ -785,7 +785,7 @@
     double fixed_cost;
 
     // IterationSummary for each minimizer iteration in order.
-    vector<IterationSummary> iterations;
+    std::vector<IterationSummary> iterations;
 
     // Number of minimizer iterations in which the step was
     // accepted. Unless use_non_monotonic_steps is true this is also
@@ -926,7 +926,7 @@
 
     // Size of the elimination groups given by the user as hints to
     // the linear solver.
-    vector<int> linear_solver_ordering_given;
+    std::vector<int> linear_solver_ordering_given;
 
     // Size of the parameter groups used by the solver when ordering
     // the columns of the Jacobian.  This maybe different from
@@ -934,7 +934,7 @@
     // linear_solver_ordering_given blank and asked for an automatic
     // ordering, or if the problem contains some constant or inactive
     // parameter blocks.
-    vector<int> linear_solver_ordering_used;
+    std::vector<int> linear_solver_ordering_used;
 
     // True if the user asked for inner iterations to be used as part
     // of the optimization.
@@ -948,7 +948,7 @@
 
     // Size of the parameter groups given by the user for performing
     // inner iterations.
-    vector<int> inner_iteration_ordering_given;
+    std::vector<int> inner_iteration_ordering_given;
 
     // Size of the parameter groups given used by the solver for
     // performing inner iterations. This maybe different from
@@ -956,7 +956,7 @@
     // inner_iteration_ordering_given blank and asked for an automatic
     // ordering, or if the problem contains some constant or inactive
     // parameter blocks.
-    vector<int> inner_iteration_ordering_used;
+    std::vector<int> inner_iteration_ordering_used;
 
     // Type of the preconditioner requested by the user.
     PreconditionerType preconditioner_type_given;
diff --git a/internal/ceres/array_utils.cc b/internal/ceres/array_utils.cc
index 205ddaf..a22eb61 100644
--- a/internal/ceres/array_utils.cc
+++ b/internal/ceres/array_utils.cc
@@ -71,7 +71,7 @@
   }
 
   return size;
-};
+}
 
 void InvalidateArray(const int size, double* x) {
   if (x != NULL) {
diff --git a/internal/ceres/array_utils.h b/internal/ceres/array_utils.h
index 7f56947..c11129e 100644
--- a/internal/ceres/array_utils.h
+++ b/internal/ceres/array_utils.h
@@ -43,6 +43,7 @@
 #ifndef CERES_INTERNAL_ARRAY_UTILS_H_
 #define CERES_INTERNAL_ARRAY_UTILS_H_
 
+#include <string>
 #include "ceres/internal/port.h"
 
 namespace ceres {
diff --git a/internal/ceres/array_utils_test.cc b/internal/ceres/array_utils_test.cc
index 203a301..fd6a499 100644
--- a/internal/ceres/array_utils_test.cc
+++ b/internal/ceres/array_utils_test.cc
@@ -38,6 +38,8 @@
 namespace ceres {
 namespace internal {
 
+using std::vector;
+
 TEST(ArrayUtils, IsArrayValid) {
   double x[3];
   x[0] = 0.0;
diff --git a/internal/ceres/autodiff_local_parameterization_test.cc b/internal/ceres/autodiff_local_parameterization_test.cc
index a73c6a6..5401d8f 100644
--- a/internal/ceres/autodiff_local_parameterization_test.cc
+++ b/internal/ceres/autodiff_local_parameterization_test.cc
@@ -72,7 +72,7 @@
 }
 
 struct ScaledPlus {
-  ScaledPlus(const double &scale_factor)
+  explicit ScaledPlus(const double &scale_factor)
      : scale_factor_(scale_factor)
   {}
 
diff --git a/internal/ceres/block_jacobi_preconditioner.cc b/internal/ceres/block_jacobi_preconditioner.cc
index 7f79a4f..d8a7280 100644
--- a/internal/ceres/block_jacobi_preconditioner.cc
+++ b/internal/ceres/block_jacobi_preconditioner.cc
@@ -43,7 +43,7 @@
 BlockJacobiPreconditioner::BlockJacobiPreconditioner(
     const BlockSparseMatrix& A) {
   const CompressedRowBlockStructure* bs = A.block_structure();
-  vector<int> blocks(bs->cols.size());
+  std::vector<int> blocks(bs->cols.size());
   for (int i = 0; i < blocks.size(); ++i) {
     blocks[i] = bs->cols[i].size;
   }
@@ -60,7 +60,7 @@
   m_->SetZero();
   for (int i = 0; i < bs->rows.size(); ++i) {
     const int row_block_size = bs->rows[i].block.size;
-    const vector<Cell>& cells = bs->rows[i].cells;
+    const std::vector<Cell>& cells = bs->rows[i].cells;
     for (int j = 0; j < cells.size(); ++j) {
       const int block_id = cells[j].block_id;
       const int col_block_size = bs->cols[block_id].size;
diff --git a/internal/ceres/block_jacobian_writer.cc b/internal/ceres/block_jacobian_writer.cc
index f90c350..085b011 100644
--- a/internal/ceres/block_jacobian_writer.cc
+++ b/internal/ceres/block_jacobian_writer.cc
@@ -41,6 +41,9 @@
 
 namespace ceres {
 namespace internal {
+
+using std::vector;
+
 namespace {
 
 // Given the residual block ordering, build a lookup table to determine which
@@ -163,8 +166,7 @@
   }
 
   // Construct the cells in each row.
-  const vector<ResidualBlock*>& residual_blocks =
-      program_->residual_blocks();
+  const vector<ResidualBlock*>& residual_blocks = program_->residual_blocks();
   int row_block_position = 0;
   bs->rows.resize(residual_blocks.size());
   for (int i = 0; i < residual_blocks.size(); ++i) {
diff --git a/internal/ceres/block_jacobian_writer.h b/internal/ceres/block_jacobian_writer.h
index 140c721..1fb52a5 100644
--- a/internal/ceres/block_jacobian_writer.h
+++ b/internal/ceres/block_jacobian_writer.h
@@ -115,10 +115,10 @@
   //
   // which indicates that dr/dx is located at values_[0], and dr/dz is at
   // values_[12]. See BlockEvaluatePreparer::Prepare()'s comments about 'j'.
-  vector<int*> jacobian_layout_;
+  std::vector<int*> jacobian_layout_;
 
   // The pointers in jacobian_layout_ point directly into this vector.
-  vector<int> jacobian_layout_storage_;
+  std::vector<int> jacobian_layout_storage_;
 };
 
 }  // namespace internal
diff --git a/internal/ceres/block_random_access_dense_matrix.cc b/internal/ceres/block_random_access_dense_matrix.cc
index e582279..d8a6b33 100644
--- a/internal/ceres/block_random_access_dense_matrix.cc
+++ b/internal/ceres/block_random_access_dense_matrix.cc
@@ -39,7 +39,7 @@
 namespace internal {
 
 BlockRandomAccessDenseMatrix::BlockRandomAccessDenseMatrix(
-    const vector<int>& blocks) {
+    const std::vector<int>& blocks) {
   const int num_blocks = blocks.size();
   block_layout_.resize(num_blocks, 0);
   num_rows_ = 0;
diff --git a/internal/ceres/block_random_access_dense_matrix.h b/internal/ceres/block_random_access_dense_matrix.h
index d160fd9..7de3303 100644
--- a/internal/ceres/block_random_access_dense_matrix.h
+++ b/internal/ceres/block_random_access_dense_matrix.h
@@ -56,7 +56,7 @@
  public:
   // blocks is a vector of block sizes. The resulting matrix has
   // blocks.size() * blocks.size() cells.
-  explicit BlockRandomAccessDenseMatrix(const vector<int>& blocks);
+  explicit BlockRandomAccessDenseMatrix(const std::vector<int>& blocks);
 
   // The destructor is not thread safe. It assumes that no one is
   // modifying any cells when the matrix is being destroyed.
@@ -85,7 +85,7 @@
 
  private:
   int num_rows_;
-  vector<int> block_layout_;
+  std::vector<int> block_layout_;
   scoped_array<double> values_;
   scoped_array<CellInfo> cell_infos_;
 
diff --git a/internal/ceres/block_random_access_dense_matrix_test.cc b/internal/ceres/block_random_access_dense_matrix_test.cc
index 359eb93..fde0a9c 100644
--- a/internal/ceres/block_random_access_dense_matrix_test.cc
+++ b/internal/ceres/block_random_access_dense_matrix_test.cc
@@ -37,7 +37,7 @@
 namespace internal {
 
 TEST(BlockRandomAccessDenseMatrix, GetCell) {
-  vector<int> blocks;
+  std::vector<int> blocks;
   blocks.push_back(3);
   blocks.push_back(4);
   blocks.push_back(5);
@@ -69,7 +69,7 @@
 }
 
 TEST(BlockRandomAccessDenseMatrix, WriteCell) {
-  vector<int> blocks;
+  std::vector<int> blocks;
   blocks.push_back(3);
   blocks.push_back(4);
   blocks.push_back(5);
diff --git a/internal/ceres/block_random_access_diagonal_matrix.cc b/internal/ceres/block_random_access_diagonal_matrix.cc
index b7ff331..d4ce4ad 100644
--- a/internal/ceres/block_random_access_diagonal_matrix.cc
+++ b/internal/ceres/block_random_access_diagonal_matrix.cc
@@ -45,6 +45,8 @@
 namespace ceres {
 namespace internal {
 
+using std::vector;
+
 // TODO(sameeragarwal): Drop the dependence on TripletSparseMatrix.
 
 BlockRandomAccessDiagonalMatrix::BlockRandomAccessDiagonalMatrix(
diff --git a/internal/ceres/block_random_access_diagonal_matrix.h b/internal/ceres/block_random_access_diagonal_matrix.h
index ea99678..e57ed5e 100644
--- a/internal/ceres/block_random_access_diagonal_matrix.h
+++ b/internal/ceres/block_random_access_diagonal_matrix.h
@@ -52,7 +52,7 @@
 class BlockRandomAccessDiagonalMatrix : public BlockRandomAccessMatrix {
  public:
   // blocks is an array of block sizes.
-  explicit BlockRandomAccessDiagonalMatrix(const vector<int>& blocks);
+  explicit BlockRandomAccessDiagonalMatrix(const std::vector<int>& blocks);
 
   // The destructor is not thread safe. It assumes that no one is
   // modifying any cells when the matrix is being destroyed.
@@ -85,8 +85,8 @@
 
  private:
   // row/column block sizes.
-  const vector<int> blocks_;
-  vector<CellInfo*> layout_;
+  const std::vector<int> blocks_;
+  std::vector<CellInfo*> layout_;
 
   // The underlying matrix object which actually stores the cells.
   scoped_ptr<TripletSparseMatrix> tsm_;
diff --git a/internal/ceres/block_random_access_diagonal_matrix_test.cc b/internal/ceres/block_random_access_diagonal_matrix_test.cc
index aa2d664..9308861 100644
--- a/internal/ceres/block_random_access_diagonal_matrix_test.cc
+++ b/internal/ceres/block_random_access_diagonal_matrix_test.cc
@@ -43,7 +43,7 @@
 class BlockRandomAccessDiagonalMatrixTest : public ::testing::Test {
  public:
   void SetUp() {
-    vector<int> blocks;
+    std::vector<int> blocks;
     blocks.push_back(3);
     blocks.push_back(4);
     blocks.push_back(5);
diff --git a/internal/ceres/block_random_access_sparse_matrix.cc b/internal/ceres/block_random_access_sparse_matrix.cc
index c43a9b7..f146403 100644
--- a/internal/ceres/block_random_access_sparse_matrix.cc
+++ b/internal/ceres/block_random_access_sparse_matrix.cc
@@ -44,6 +44,11 @@
 namespace ceres {
 namespace internal {
 
+using std::make_pair;
+using std::pair;
+using std::set;
+using std::vector;
+
 BlockRandomAccessSparseMatrix::BlockRandomAccessSparseMatrix(
     const vector<int>& blocks,
     const set<pair<int, int> >& block_pairs)
diff --git a/internal/ceres/block_random_access_sparse_matrix.h b/internal/ceres/block_random_access_sparse_matrix.h
index 51b5d20..1b7d9c1 100644
--- a/internal/ceres/block_random_access_sparse_matrix.h
+++ b/internal/ceres/block_random_access_sparse_matrix.h
@@ -57,8 +57,9 @@
   // blocks is an array of block sizes. block_pairs is a set of
   // <row_block_id, col_block_id> pairs to identify the non-zero cells
   // of this matrix.
-  BlockRandomAccessSparseMatrix(const vector<int>& blocks,
-                                const set<pair<int, int> >& block_pairs);
+  BlockRandomAccessSparseMatrix(
+      const std::vector<int>& blocks,
+      const std::set<std::pair<int, int> >& block_pairs);
 
   // The destructor is not thread safe. It assumes that no one is
   // modifying any cells when the matrix is being destroyed.
@@ -103,8 +104,8 @@
   const int64 kMaxRowBlocks;
 
   // row/column block sizes.
-  const vector<int> blocks_;
-  vector<int> block_positions_;
+  const std::vector<int> blocks_;
+  std::vector<int> block_positions_;
 
   // A mapping from <row_block_id, col_block_id> to the position in
   // the values array of tsm_ where the block is stored.
@@ -114,7 +115,7 @@
   // In order traversal of contents of the matrix. This allows us to
   // implement a matrix-vector which is 20% faster than using the
   // iterator in the Layout object instead.
-  vector<pair<pair<int, int>, double*> > cell_values_;
+  std::vector<std::pair<std::pair<int, int>, double*> > cell_values_;
   // The underlying matrix object which actually stores the cells.
   scoped_ptr<TripletSparseMatrix> tsm_;
 
diff --git a/internal/ceres/block_random_access_sparse_matrix_test.cc b/internal/ceres/block_random_access_sparse_matrix_test.cc
index 10a4190..e6147dd 100644
--- a/internal/ceres/block_random_access_sparse_matrix_test.cc
+++ b/internal/ceres/block_random_access_sparse_matrix_test.cc
@@ -38,6 +38,11 @@
 namespace ceres {
 namespace internal {
 
+using std::make_pair;
+using std::pair;
+using std::set;
+using std::vector;
+
 TEST(BlockRandomAccessSparseMatrix, GetCell) {
   vector<int> blocks;
   blocks.push_back(3);
@@ -169,7 +174,8 @@
 };
 
 TEST_F(BlockRandomAccessSparseMatrixTest, IntPairToLongOverflow) {
-  CheckIntPairToLong(numeric_limits<int>::max(), numeric_limits<int>::max());
+  CheckIntPairToLong(std::numeric_limits<int>::max(),
+                     std::numeric_limits<int>::max());
 }
 
 TEST_F(BlockRandomAccessSparseMatrixTest, LongToIntPair) {
diff --git a/internal/ceres/block_sparse_matrix.cc b/internal/ceres/block_sparse_matrix.cc
index a487262..6aa3c00 100644
--- a/internal/ceres/block_sparse_matrix.cc
+++ b/internal/ceres/block_sparse_matrix.cc
@@ -42,6 +42,8 @@
 namespace ceres {
 namespace internal {
 
+using std::vector;
+
 BlockSparseMatrix::~BlockSparseMatrix() {}
 
 BlockSparseMatrix::BlockSparseMatrix(
@@ -82,7 +84,7 @@
 }
 
 void BlockSparseMatrix::SetZero() {
-  fill(values_.get(), values_.get() + num_nonzeros_, 0.0);
+  std::fill(values_.get(), values_.get() + num_nonzeros_, 0.0);
 }
 
 void BlockSparseMatrix::RightMultiply(const double* x,  double* y) const {
diff --git a/internal/ceres/block_structure.h b/internal/ceres/block_structure.h
index 656716e..dde8f67 100644
--- a/internal/ceres/block_structure.h
+++ b/internal/ceres/block_structure.h
@@ -71,20 +71,20 @@
 
 struct CompressedList {
   Block block;
-  vector<Cell> cells;
+  std::vector<Cell> cells;
 };
 
 typedef CompressedList CompressedRow;
 typedef CompressedList CompressedColumn;
 
 struct CompressedRowBlockStructure {
-  vector<Block> cols;
-  vector<CompressedRow> rows;
+  std::vector<Block> cols;
+  std::vector<CompressedRow> rows;
 };
 
 struct CompressedColumnBlockStructure {
-  vector<Block> rows;
-  vector<CompressedColumn> cols;
+  std::vector<Block> rows;
+  std::vector<CompressedColumn> cols;
 };
 
 }  // namespace internal
diff --git a/internal/ceres/callbacks.cc b/internal/ceres/callbacks.cc
index 7d5ce25..3858309 100644
--- a/internal/ceres/callbacks.cc
+++ b/internal/ceres/callbacks.cc
@@ -78,27 +78,27 @@
                           summary.cumulative_time_in_seconds);
   } else if (minimizer_type == TRUST_REGION) {
     if (summary.iteration == 0) {
-      output = "iter      cost      cost_change  |gradient|   |step|    tr_ratio  tr_radius  ls_iter  iter_time  total_time\n";
+      output = "iter      cost      cost_change  |gradient|   |step|    tr_ratio  tr_radius  ls_iter  iter_time  total_time\n";  // NOLINT
     }
     const char* kReportRowFormat =
-        "% 4d % 8e   % 3.2e   % 3.2e  % 3.2e  % 3.2e % 3.2e     % 4d   % 3.2e   % 3.2e";
+        "% 4d % 8e   % 3.2e   % 3.2e  % 3.2e  % 3.2e % 3.2e     % 4d   % 3.2e   % 3.2e";  // NOLINT
     output += StringPrintf(kReportRowFormat,
-                          summary.iteration,
-                          summary.cost,
-                          summary.cost_change,
-                          summary.gradient_max_norm,
-                          summary.step_norm,
-                          summary.relative_decrease,
-                          summary.trust_region_radius,
-                          summary.linear_solver_iterations,
-                          summary.iteration_time_in_seconds,
-                          summary.cumulative_time_in_seconds);
+                           summary.iteration,
+                           summary.cost,
+                           summary.cost_change,
+                           summary.gradient_max_norm,
+                           summary.step_norm,
+                           summary.relative_decrease,
+                           summary.trust_region_radius,
+                           summary.linear_solver_iterations,
+                           summary.iteration_time_in_seconds,
+                           summary.cumulative_time_in_seconds);
   } else {
     LOG(FATAL) << "Unknown minimizer type.";
   }
 
   if (log_to_stdout_) {
-    cout << output << endl;
+    std::cout << output << std::endl;
   } else {
     VLOG(1) << output;
   }
diff --git a/internal/ceres/canonical_views_clustering.cc b/internal/ceres/canonical_views_clustering.cc
index 9bbab4b..c629a44 100644
--- a/internal/ceres/canonical_views_clustering.cc
+++ b/internal/ceres/canonical_views_clustering.cc
@@ -45,6 +45,8 @@
 namespace ceres {
 namespace internal {
 
+using std::vector;
+
 typedef HashMap<int, int> IntMap;
 typedef HashSet<int> IntSet;
 
diff --git a/internal/ceres/canonical_views_clustering.h b/internal/ceres/canonical_views_clustering.h
index d3fa572..1518ac9 100644
--- a/internal/ceres/canonical_views_clustering.h
+++ b/internal/ceres/canonical_views_clustering.h
@@ -102,7 +102,7 @@
 void ComputeCanonicalViewsClustering(
     const CanonicalViewsClusteringOptions& options,
     const WeightedGraph<int>& graph,
-    vector<int>* centers,
+    std::vector<int>* centers,
     HashMap<int, int>* membership);
 
 struct CanonicalViewsClusteringOptions {
diff --git a/internal/ceres/canonical_views_clustering_test.cc b/internal/ceres/canonical_views_clustering_test.cc
index 006b2dd..0a0e3c5 100644
--- a/internal/ceres/canonical_views_clustering_test.cc
+++ b/internal/ceres/canonical_views_clustering_test.cc
@@ -78,7 +78,7 @@
   WeightedGraph<int> graph_;
 
   CanonicalViewsClusteringOptions options_;
-  vector<int> centers_;
+  std::vector<int> centers_;
   HashMap<int, int> membership_;
 };
 
diff --git a/internal/ceres/collections_port.h b/internal/ceres/collections_port.h
index 3f976b9..3c23856 100644
--- a/internal/ceres/collections_port.h
+++ b/internal/ceres/collections_port.h
@@ -69,7 +69,6 @@
 
 #include <utility>
 #include "ceres/integral_types.h"
-#include "ceres/internal/port.h"
 
 // Some systems don't have access to unordered_map/unordered_set. In
 // that case, substitute the hash map/set with normal map/set. The
diff --git a/internal/ceres/compressed_col_sparse_matrix_utils.cc b/internal/ceres/compressed_col_sparse_matrix_utils.cc
index b62a6ed..f4af098 100644
--- a/internal/ceres/compressed_col_sparse_matrix_utils.cc
+++ b/internal/ceres/compressed_col_sparse_matrix_utils.cc
@@ -38,12 +38,15 @@
 namespace ceres {
 namespace internal {
 
-void CompressedColumnScalarMatrixToBlockMatrix(const int* scalar_rows,
-                                               const int* scalar_cols,
-                                               const vector<int>& row_blocks,
-                                               const vector<int>& col_blocks,
-                                               vector<int>* block_rows,
-                                               vector<int>* block_cols) {
+using std::vector;
+
+void CompressedColumnScalarMatrixToBlockMatrix(
+    const int* scalar_rows,
+    const int* scalar_cols,
+    const vector<int>& row_blocks,
+    const vector<int>& col_blocks,
+    vector<int>* block_rows,
+    vector<int>* block_cols) {
   CHECK_NOTNULL(block_rows)->clear();
   CHECK_NOTNULL(block_cols)->clear();
   const int num_row_blocks = row_blocks.size();
@@ -66,9 +69,10 @@
   for (int col_block = 0; col_block < num_col_blocks; ++col_block) {
     int column_size = 0;
     for (int idx = scalar_cols[c]; idx < scalar_cols[c + 1]; ++idx) {
-      vector<int>::const_iterator it = lower_bound(row_block_starts.begin(),
-                                                   row_block_starts.end(),
-                                                   scalar_rows[idx]);
+      vector<int>::const_iterator it =
+          std::lower_bound(row_block_starts.begin(),
+                           row_block_starts.end(),
+                           scalar_rows[idx]);
       // Since we are using lower_bound, it will return the row id
       // where the row block starts. For everything but the first row
       // of the block, where these values will be the same, we can
diff --git a/internal/ceres/compressed_col_sparse_matrix_utils.h b/internal/ceres/compressed_col_sparse_matrix_utils.h
index c8de2a1..e27eaa3 100644
--- a/internal/ceres/compressed_col_sparse_matrix_utils.h
+++ b/internal/ceres/compressed_col_sparse_matrix_utils.h
@@ -47,19 +47,21 @@
 // and column block j, then it is expected that A contains at least
 // one non-zero entry corresponding to the top left entry of c_ij,
 // as that entry is used to detect the presence of a non-zero c_ij.
-void CompressedColumnScalarMatrixToBlockMatrix(const int* scalar_rows,
-                                               const int* scalar_cols,
-                                               const vector<int>& row_blocks,
-                                               const vector<int>& col_blocks,
-                                               vector<int>* block_rows,
-                                               vector<int>* block_cols);
+void CompressedColumnScalarMatrixToBlockMatrix(
+    const int* scalar_rows,
+    const int* scalar_cols,
+    const std::vector<int>& row_blocks,
+    const std::vector<int>& col_blocks,
+    std::vector<int>* block_rows,
+    std::vector<int>* block_cols);
 
 // Given a set of blocks and a permutation of these blocks, compute
 // the corresponding "scalar" ordering, where the scalar ordering of
 // size sum(blocks).
-void BlockOrderingToScalarOrdering(const vector<int>& blocks,
-                                   const vector<int>& block_ordering,
-                                   vector<int>* scalar_ordering);
+void BlockOrderingToScalarOrdering(
+    const std::vector<int>& blocks,
+    const std::vector<int>& block_ordering,
+    std::vector<int>* scalar_ordering);
 
 // Solve the linear system
 //
@@ -120,7 +122,7 @@
                            const double* values,
                            const int rhs_nonzero_index,
                            double* solution) {
-  fill(solution, solution + num_cols, 0.0);
+  std::fill(solution, solution + num_cols, 0.0);
   solution[rhs_nonzero_index] = 1.0 / values[cols[rhs_nonzero_index + 1] - 1];
 
   for (IntegerType c = rhs_nonzero_index + 1; c < num_cols; ++c) {
diff --git a/internal/ceres/compressed_col_sparse_matrix_utils_test.cc b/internal/ceres/compressed_col_sparse_matrix_utils_test.cc
index 3faf06c..5f1fd8f 100644
--- a/internal/ceres/compressed_col_sparse_matrix_utils_test.cc
+++ b/internal/ceres/compressed_col_sparse_matrix_utils_test.cc
@@ -39,6 +39,8 @@
 namespace ceres {
 namespace internal {
 
+using std::vector;
+
 TEST(_, BlockPermutationToScalarPermutation) {
   vector<int> blocks;
   //  Block structure
@@ -133,7 +135,7 @@
   TripletSparseMatrix tsm(5, 8, 18);
   int* rows = tsm.mutable_rows();
   int* cols = tsm.mutable_cols();
-  fill(tsm.mutable_values(), tsm.mutable_values() + 18, 1.0);
+  std::fill(tsm.mutable_values(), tsm.mutable_values() + 18, 1.0);
   int offset = 0;
 
 #define CERES_TEST_FILL_BLOCK(row_block_id, col_block_id) \
diff --git a/internal/ceres/compressed_row_jacobian_writer.cc b/internal/ceres/compressed_row_jacobian_writer.cc
index ed8db14..9860b82 100644
--- a/internal/ceres/compressed_row_jacobian_writer.cc
+++ b/internal/ceres/compressed_row_jacobian_writer.cc
@@ -30,6 +30,9 @@
 
 #include "ceres/compressed_row_jacobian_writer.h"
 
+#include <utility>
+#include <vector>
+
 #include "ceres/casts.h"
 #include "ceres/compressed_row_sparse_matrix.h"
 #include "ceres/parameter_block.h"
@@ -40,6 +43,10 @@
 namespace ceres {
 namespace internal {
 
+using std::make_pair;
+using std::pair;
+using std::vector;
+
 void CompressedRowJacobianWriter::PopulateJacobianRowAndColumnBlockVectors(
     const Program* program, CompressedRowSparseMatrix* jacobian) {
   const vector<ParameterBlock*>& parameter_blocks =
@@ -214,9 +221,9 @@
       double* column_block_begin =
           jacobian_values + jacobian_rows[residual_offset + r] + col_pos;
 
-      copy(block_row_begin,
-           block_row_begin + parameter_block_size,
-           column_block_begin);
+      std::copy(block_row_begin,
+                block_row_begin + parameter_block_size,
+                column_block_begin);
     }
     col_pos += parameter_block_size;
   }
diff --git a/internal/ceres/compressed_row_jacobian_writer.h b/internal/ceres/compressed_row_jacobian_writer.h
index a722a7c..517d691 100644
--- a/internal/ceres/compressed_row_jacobian_writer.h
+++ b/internal/ceres/compressed_row_jacobian_writer.h
@@ -33,6 +33,9 @@
 #ifndef CERES_INTERNAL_COMPRESSED_ROW_JACOBIAN_WRITER_H_
 #define CERES_INTERNAL_COMPRESSED_ROW_JACOBIAN_WRITER_H_
 
+#include <utility>
+#include <vector>
+
 #include "ceres/evaluator.h"
 #include "ceres/scratch_evaluate_preparer.h"
 
@@ -80,7 +83,7 @@
   static void GetOrderedParameterBlocks(
       const Program* program,
       int residual_id,
-      vector<pair<int, int> >* evaluated_jacobian_blocks);
+      std::vector<std::pair<int, int> >* evaluated_jacobian_blocks);
 
   // JacobianWriter interface.
 
diff --git a/internal/ceres/compressed_row_sparse_matrix.cc b/internal/ceres/compressed_row_sparse_matrix.cc
index 7993ed6..b036bb5 100644
--- a/internal/ceres/compressed_row_sparse_matrix.cc
+++ b/internal/ceres/compressed_row_sparse_matrix.cc
@@ -40,6 +40,9 @@
 
 namespace ceres {
 namespace internal {
+
+using std::vector;
+
 namespace {
 
 // Helper functor used by the constructor for reordering the contents
@@ -155,7 +158,7 @@
 }
 
 void CompressedRowSparseMatrix::SetZero() {
-  fill(values_.begin(), values_.end(), 0);
+  std::fill(values_.begin(), values_.end(), 0);
 }
 
 void CompressedRowSparseMatrix::RightMultiply(const double* x,
@@ -184,7 +187,7 @@
 void CompressedRowSparseMatrix::SquaredColumnNorm(double* x) const {
   CHECK_NOTNULL(x);
 
-  fill(x, x + num_cols_, 0.0);
+  std::fill(x, x + num_cols_, 0.0);
   for (int idx = 0; idx < rows_[num_rows_]; ++idx) {
     x[cols_[idx]] += values_[idx] * values_[idx];
   }
@@ -244,20 +247,24 @@
   }
 
   // Copy the contents of m into this matrix.
-  copy(m.cols(), m.cols() + m.num_nonzeros(), &cols_[num_nonzeros()]);
-  copy(m.values(), m.values() + m.num_nonzeros(), &values_[num_nonzeros()]);
+  std::copy(m.cols(), m.cols() + m.num_nonzeros(), &cols_[num_nonzeros()]);
+  std::copy(m.values(),
+            m.values() + m.num_nonzeros(),
+            &values_[num_nonzeros()]);
   rows_.resize(num_rows_ + m.num_rows() + 1);
   // new_rows = [rows_, m.row() + rows_[num_rows_]]
-  fill(rows_.begin() + num_rows_,
-       rows_.begin() + num_rows_ + m.num_rows() + 1,
-       rows_[num_rows_]);
+  std::fill(rows_.begin() + num_rows_,
+            rows_.begin() + num_rows_ + m.num_rows() + 1,
+            rows_[num_rows_]);
 
   for (int r = 0; r < m.num_rows() + 1; ++r) {
     rows_[num_rows_ + r] += m.rows()[r];
   }
 
   num_rows_ += m.num_rows();
-  row_blocks_.insert(row_blocks_.end(), m.row_blocks().begin(), m.row_blocks().end());
+  row_blocks_.insert(row_blocks_.end(),
+                     m.row_blocks().begin(),
+                     m.row_blocks().end());
 }
 
 void CompressedRowSparseMatrix::ToTextFile(FILE* file) const {
@@ -329,7 +336,7 @@
   int* rows = matrix->mutable_rows();
   int* cols = matrix->mutable_cols();
   double* values = matrix->mutable_values();
-  fill(values, values + num_nonzeros, 0.0);
+  std::fill(values, values + num_nonzeros, 0.0);
 
   int idx_cursor = 0;
   int col_cursor = 0;
@@ -481,8 +488,9 @@
       const CompressedRowSparseMatrix& m,
       vector<int>* program) {
   CHECK_NOTNULL(program)->clear();
-  CHECK_GT(m.num_nonzeros(), 0) << "Congratulations, "
-                                << "you found a bug in Ceres. Please report it.";
+  CHECK_GT(m.num_nonzeros(), 0)
+                << "Congratulations, "
+                << "you found a bug in Ceres. Please report it.";
 
   vector<ProductTerm> product;
   const vector<int>& row_blocks = m.row_blocks();
@@ -495,7 +503,9 @@
     // Compute the lower triangular part of the product.
     for (int idx1 = m.rows()[r]; idx1 < m.rows()[r + 1]; ++idx1) {
       for (int idx2 = m.rows()[r]; idx2 <= idx1; ++idx2) {
-        product.push_back(ProductTerm(m.cols()[idx1], m.cols()[idx2], product.size()));
+        product.push_back(ProductTerm(m.cols()[idx1],
+                                      m.cols()[idx2],
+                                      product.size()));
       }
     }
     row_block_begin = row_block_end;
diff --git a/internal/ceres/compressed_row_sparse_matrix.h b/internal/ceres/compressed_row_sparse_matrix.h
index a0ba7ee..13470ce 100644
--- a/internal/ceres/compressed_row_sparse_matrix.h
+++ b/internal/ceres/compressed_row_sparse_matrix.h
@@ -109,11 +109,11 @@
   const int* rows() const { return &rows_[0]; }
   int* mutable_rows() { return &rows_[0]; }
 
-  const vector<int>& row_blocks() const { return row_blocks_; }
-  vector<int>* mutable_row_blocks() { return &row_blocks_; }
+  const std::vector<int>& row_blocks() const { return row_blocks_; }
+  std::vector<int>* mutable_row_blocks() { return &row_blocks_; }
 
-  const vector<int>& col_blocks() const { return col_blocks_; }
-  vector<int>* mutable_col_blocks() { return &col_blocks_; }
+  const std::vector<int>& col_blocks() const { return col_blocks_; }
+  std::vector<int>* mutable_col_blocks() { return &col_blocks_; }
 
   // Destructive array resizing method.
   void SetMaxNumNonZeros(int num_nonzeros);
@@ -129,7 +129,7 @@
 
   static CompressedRowSparseMatrix* CreateBlockDiagonalMatrix(
       const double* diagonal,
-      const vector<int>& blocks);
+      const std::vector<int>& blocks);
 
   // Compute the sparsity structure of the product m.transpose() * m
   // and create a CompressedRowSparseMatrix corresponding to it.
@@ -147,30 +147,30 @@
   // this information for each row in the row block.
   static CompressedRowSparseMatrix* CreateOuterProductMatrixAndProgram(
       const CompressedRowSparseMatrix& m,
-      vector<int>* program);
+      std::vector<int>* program);
 
   // Compute the values array for the expression m.transpose() * m,
   // where the matrix used to store the result and a program have been
   // created using the CreateOuterProductMatrixAndProgram function
   // above.
   static void ComputeOuterProduct(const CompressedRowSparseMatrix& m,
-                                  const vector<int>& program,
+                                  const std::vector<int>& program,
                                   CompressedRowSparseMatrix* result);
 
  private:
   int num_rows_;
   int num_cols_;
-  vector<int> rows_;
-  vector<int> cols_;
-  vector<double> values_;
+  std::vector<int> rows_;
+  std::vector<int> cols_;
+  std::vector<double> values_;
 
   // If the matrix has an underlying block structure, then it can also
   // carry with it row and column block sizes. This is auxilliary and
   // optional information for use by algorithms operating on the
   // matrix. The class itself does not make use of this information in
   // any way.
-  vector<int> row_blocks_;
-  vector<int> col_blocks_;
+  std::vector<int> row_blocks_;
+  std::vector<int> col_blocks_;
 
   CERES_DISALLOW_COPY_AND_ASSIGN(CompressedRowSparseMatrix);
 };
diff --git a/internal/ceres/compressed_row_sparse_matrix_test.cc b/internal/ceres/compressed_row_sparse_matrix_test.cc
index 999a661..5a210ae 100644
--- a/internal/ceres/compressed_row_sparse_matrix_test.cc
+++ b/internal/ceres/compressed_row_sparse_matrix_test.cc
@@ -45,6 +45,8 @@
 namespace ceres {
 namespace internal {
 
+using std::vector;
+
 void CompareMatrices(const SparseMatrix* a, const SparseMatrix* b) {
   EXPECT_EQ(a->num_rows(), b->num_rows());
   EXPECT_EQ(a->num_cols(), b->num_cols());
@@ -169,7 +171,7 @@
 
   scoped_array<double> diagonal(new double[num_diagonal_rows]);
   for (int i = 0; i < num_diagonal_rows; ++i) {
-    diagonal[i] =i;
+    diagonal[i] = i;
   }
 
   vector<int> row_and_column_blocks;
@@ -384,7 +386,7 @@
   cols[16] = 2;
   rows[5] = 17;
 
-  copy(values, values + 17, cols);
+  std::copy(values, values + 17, cols);
 
   scoped_ptr<CompressedRowSparseMatrix> transpose(matrix.Transpose());
 
@@ -478,11 +480,11 @@
   dense_matrix->setZero();
 
   for (int c = 0; c < matrix->n; ++c) {
-   for (int idx = matrix->p[c]; idx < matrix->p[c + 1]; ++idx) {
-     const int r = matrix->i[idx];
-     (*dense_matrix)(r, c) = matrix->x[idx];
-   }
- }
+    for (int idx = matrix->p[c]; idx < matrix->p[c + 1]; ++idx) {
+      const int r = matrix->i[idx];
+      (*dense_matrix)(r, c) = matrix->x[idx];
+    }
+  }
 }
 
 TEST(CompressedRowSparseMatrix, ComputeOuterProduct) {
@@ -506,8 +508,6 @@
          num_col_blocks < kMaxNumColBlocks;
          ++num_col_blocks) {
       for (int trial = 0; trial < kNumTrials; ++trial) {
-
-
         RandomMatrixOptions options;
         options.num_row_blocks = num_row_blocks;
         options.num_col_blocks = num_col_blocks;
@@ -528,7 +528,8 @@
         scoped_ptr<CompressedRowSparseMatrix> matrix(
             CreateRandomCompressedRowSparseMatrix(options));
 
-        cs_di cs_matrix_transpose = cxsparse.CreateSparseMatrixTransposeView(matrix.get());
+        cs_di cs_matrix_transpose =
+            cxsparse.CreateSparseMatrixTransposeView(matrix.get());
         cs_di* cs_matrix = cxsparse.TransposeMatrix(&cs_matrix_transpose);
         cs_di* expected_outer_product =
             cxsparse.MatrixMatrixMultiply(&cs_matrix_transpose, cs_matrix);
@@ -555,7 +556,8 @@
         expected_matrix.triangularView<Eigen::StrictlyLower>().setZero();
 
         ToDenseMatrix(&actual_outer_product, &actual_matrix);
-        const double diff_norm = (actual_matrix - expected_matrix).norm() / expected_matrix.norm();
+        const double diff_norm =
+            (actual_matrix - expected_matrix).norm() / expected_matrix.norm();
         ASSERT_NEAR(diff_norm, 0.0, kTolerance)
             << "expected: \n"
             << expected_matrix
diff --git a/internal/ceres/conditioned_cost_function.cc b/internal/ceres/conditioned_cost_function.cc
index 7322790..029dd5c 100644
--- a/internal/ceres/conditioned_cost_function.cc
+++ b/internal/ceres/conditioned_cost_function.cc
@@ -45,7 +45,7 @@
 // the one it's wrapping.
 ConditionedCostFunction::ConditionedCostFunction(
     CostFunction* wrapped_cost_function,
-    const vector<CostFunction*>& conditioners,
+    const std::vector<CostFunction*>& conditioners,
     Ownership ownership)
     : wrapped_cost_function_(wrapped_cost_function),
       conditioners_(conditioners),
diff --git a/internal/ceres/conditioned_cost_function_test.cc b/internal/ceres/conditioned_cost_function_test.cc
index 03c553f..ad44653 100644
--- a/internal/ceres/conditioned_cost_function_test.cc
+++ b/internal/ceres/conditioned_cost_function_test.cc
@@ -87,7 +87,7 @@
   identity.setIdentity();
   NormalPrior* difference_cost_function = new NormalPrior(identity, v2_vector);
 
-  vector<CostFunction*> conditioners;
+  std::vector<CostFunction*> conditioners;
   for (int i = 0; i < kTestCostFunctionSize; i++) {
     conditioners.push_back(new LinearCostFunction(i + 2, i * 7));
   }
diff --git a/internal/ceres/conjugate_gradients_solver.cc b/internal/ceres/conjugate_gradients_solver.cc
index 3071a09..92e829c 100644
--- a/internal/ceres/conjugate_gradients_solver.cc
+++ b/internal/ceres/conjugate_gradients_solver.cc
@@ -114,7 +114,6 @@
   double Q0 = -1.0 * xref.dot(bref + r);
 
   for (summary.num_iterations = 1;; ++summary.num_iterations) {
-
     // Apply preconditioner
     if (per_solve_options.preconditioner != NULL) {
       z.setZero();
@@ -129,7 +128,7 @@
       summary.termination_type = LINEAR_SOLVER_FAILURE;
       summary.message = StringPrintf("Numerical failure. rho = r'z = %e.", rho);
       break;
-    };
+    }
 
     if (summary.num_iterations == 1) {
       p = z;
@@ -233,7 +232,7 @@
   }
 
   return summary;
-};
+}
 
 }  // namespace internal
 }  // namespace ceres
diff --git a/internal/ceres/coordinate_descent_minimizer.cc b/internal/ceres/coordinate_descent_minimizer.cc
index 0d8adee..9f14840 100644
--- a/internal/ceres/coordinate_descent_minimizer.cc
+++ b/internal/ceres/coordinate_descent_minimizer.cc
@@ -48,11 +48,14 @@
 #include "ceres/solver.h"
 #include "ceres/trust_region_minimizer.h"
 #include "ceres/trust_region_strategy.h"
-#include "ceres/parameter_block_ordering.h"
 
 namespace ceres {
 namespace internal {
 
+using std::map;
+using std::set;
+using std::vector;
+
 CoordinateDescentMinimizer::~CoordinateDescentMinimizer() {
 }
 
@@ -103,8 +106,7 @@
     const int num_parameter_blocks = residual_block->NumParameterBlocks();
     for (int j = 0; j < num_parameter_blocks; ++j) {
       ParameterBlock* parameter_block = residual_block->parameter_blocks()[j];
-      const map<ParameterBlock*, int>::const_iterator it =
-          parameter_block_index.find(parameter_block);
+      const map<ParameterBlock*, int>::const_iterator it = parameter_block_index.find(parameter_block);
       if (it != parameter_block_index.end()) {
         residual_blocks_[it->second].push_back(residual_block);
       }
@@ -244,7 +246,7 @@
 
   // Verify that each group is an independent set
   map<int, set<double*> >::const_iterator it = group_to_elements.begin();
-  for ( ; it != group_to_elements.end(); ++it) {
+  for (; it != group_to_elements.end(); ++it) {
     if (!program.IsParameterBlockSetIndependent(it->second)) {
       *message =
           StringPrintf("The user-provided "
diff --git a/internal/ceres/coordinate_descent_minimizer.h b/internal/ceres/coordinate_descent_minimizer.h
index c1f8ffc..7aed5d3 100644
--- a/internal/ceres/coordinate_descent_minimizer.h
+++ b/internal/ceres/coordinate_descent_minimizer.h
@@ -85,13 +85,13 @@
              double* parameters,
              Solver::Summary* summary);
 
-  vector<ParameterBlock*> parameter_blocks_;
-  vector<vector<ResidualBlock*> > residual_blocks_;
+  std::vector<ParameterBlock*> parameter_blocks_;
+  std::vector<std::vector<ResidualBlock*> > residual_blocks_;
   // The optimization is performed in rounds. In each round all the
   // parameter blocks that form one independent set are optimized in
   // parallel. This array, marks the boundaries of the independent
   // sets in parameter_blocks_.
-  vector<int> independent_set_offsets_;
+  std::vector<int> independent_set_offsets_;
 
   Evaluator::Options evaluator_options_;
 };
diff --git a/internal/ceres/cost_function_to_functor_test.cc b/internal/ceres/cost_function_to_functor_test.cc
index f758efe..db29fe4 100644
--- a/internal/ceres/cost_function_to_functor_test.cc
+++ b/internal/ceres/cost_function_to_functor_test.cc
@@ -35,6 +35,7 @@
 namespace ceres {
 namespace internal {
 
+using std::vector;
 const double kTolerance = 1e-18;
 
 void ExpectCostFunctionsAreEqual(const CostFunction& cost_function,
@@ -109,7 +110,7 @@
         << "jacobian : " << i << " "
         << jacobians[i] << " " << actual_jacobians[i];
   }
-};
+}
 
 struct OneParameterBlockFunctor {
  public:
diff --git a/internal/ceres/covariance.cc b/internal/ceres/covariance.cc
index 35146c5..4955f4a 100644
--- a/internal/ceres/covariance.cc
+++ b/internal/ceres/covariance.cc
@@ -38,6 +38,9 @@
 
 namespace ceres {
 
+using std::pair;
+using std::vector;
+
 Covariance::Covariance(const Covariance::Options& options) {
   impl_.reset(new internal::CovarianceImpl(options));
 }
diff --git a/internal/ceres/covariance_impl.cc b/internal/ceres/covariance_impl.cc
index cbbf139..e5d0c44 100644
--- a/internal/ceres/covariance_impl.cc
+++ b/internal/ceres/covariance_impl.cc
@@ -58,6 +58,12 @@
 namespace ceres {
 namespace internal {
 
+using std::make_pair;
+using std::map;
+using std::pair;
+using std::swap;
+using std::vector;
+
 typedef vector<pair<const double*, const double*> > CovarianceBlocks;
 
 CovarianceImpl::CovarianceImpl(const Covariance::Options& options)
@@ -122,7 +128,7 @@
   const double* parameter_block2 = original_parameter_block2;
   const bool transpose = parameter_block1 > parameter_block2;
   if (transpose) {
-    std::swap(parameter_block1, parameter_block2);
+    swap(parameter_block1, parameter_block2);
   }
 
   // Find where in the covariance matrix the block is located.
@@ -242,7 +248,8 @@
   problem->GetParameterBlocks(&all_parameter_blocks);
   const ProblemImpl::ParameterMap& parameter_map = problem->parameter_map();
   constant_parameter_blocks_.clear();
-  vector<double*>& active_parameter_blocks = evaluate_options_.parameter_blocks;
+  vector<double*>& active_parameter_blocks =
+      evaluate_options_.parameter_blocks;
   active_parameter_blocks.clear();
   for (int i = 0; i < all_parameter_blocks.size(); ++i) {
     double* parameter_block = all_parameter_blocks[i];
@@ -255,7 +262,7 @@
     }
   }
 
-  sort(active_parameter_blocks.begin(), active_parameter_blocks.end());
+  std::sort(active_parameter_blocks.begin(), active_parameter_blocks.end());
 
   // Compute the number of rows.  Map each parameter block to the
   // first row corresponding to it in the covariance matrix using the
@@ -594,8 +601,8 @@
       sqrt(options_.min_reciprocal_condition_number);
 
   const bool automatic_truncation = (options_.null_space_rank < 0);
-  const int max_rank = min(num_singular_values,
-                           num_singular_values - options_.null_space_rank);
+  const int max_rank = std::min(num_singular_values,
+                                num_singular_values - options_.null_space_rank);
 
   // Compute the squared inverse of the singular values. Truncate the
   // computation based on min_singular_value_ratio and
@@ -672,7 +679,7 @@
       qr_solver(sparse_jacobian);
   event_logger.AddEvent("QRDecomposition");
 
-  if(qr_solver.info() != Eigen::Success) {
+  if (qr_solver.info() != Eigen::Success) {
     LOG(ERROR) << "Eigen::SparseQR decomposition failed.";
     return false;
   }
diff --git a/internal/ceres/covariance_impl.h b/internal/ceres/covariance_impl.h
index 135f4a1..f2defe8 100644
--- a/internal/ceres/covariance_impl.h
+++ b/internal/ceres/covariance_impl.h
@@ -52,7 +52,8 @@
   ~CovarianceImpl();
 
   bool Compute(
-      const vector<pair<const double*, const double*> >& covariance_blocks,
+      const std::vector<std::pair<const double*,
+                                  const double*> >& covariance_blocks,
       ProblemImpl* problem);
 
   bool GetCovarianceBlock(const double* parameter_block1,
@@ -60,7 +61,8 @@
                           double* covariance_block) const;
 
   bool ComputeCovarianceSparsity(
-      const vector<pair<const double*, const double*> >& covariance_blocks,
+      const std::vector<std::pair<const double*,
+                                  const double*> >& covariance_blocks,
       ProblemImpl* problem);
 
   bool ComputeCovarianceValues();
@@ -78,8 +80,8 @@
   Problem::EvaluateOptions evaluate_options_;
   bool is_computed_;
   bool is_valid_;
-  map<const double*, int> parameter_block_to_row_index_;
-  set<const double*> constant_parameter_blocks_;
+  std::map<const double*, int> parameter_block_to_row_index_;
+  std::set<const double*> constant_parameter_blocks_;
   scoped_ptr<CompressedRowSparseMatrix> covariance_matrix_;
 };
 
diff --git a/internal/ceres/covariance_test.cc b/internal/ceres/covariance_test.cc
index 6c506b7..f4fae0e 100644
--- a/internal/ceres/covariance_test.cc
+++ b/internal/ceres/covariance_test.cc
@@ -43,6 +43,11 @@
 namespace ceres {
 namespace internal {
 
+using std::make_pair;
+using std::map;
+using std::pair;
+using std::vector;
+
 TEST(CovarianceImpl, ComputeCovarianceSparsity) {
   double parameters[10];
 
@@ -247,7 +252,9 @@
 
     {
       double jacobian = 5.0;
-      problem_.AddResidualBlock(new UnaryCostFunction(1, 1, &jacobian), NULL, z);
+      problem_.AddResidualBlock(new UnaryCostFunction(1, 1, &jacobian),
+                                NULL,
+                                z);
     }
 
     {
@@ -319,9 +326,15 @@
         const double* block1 = covariance_blocks[i].first;
         const double* block2 = covariance_blocks[i].second;
         // block1, block2
-        GetCovarianceBlockAndCompare(block1, block2, covariance, expected_covariance);
+        GetCovarianceBlockAndCompare(block1,
+                                     block2,
+                                     covariance,
+                                     expected_covariance);
         // block2, block1
-        GetCovarianceBlockAndCompare(block2, block1, covariance, expected_covariance);
+        GetCovarianceBlockAndCompare(block2,
+                                     block1,
+                                     covariance,
+                                     expected_covariance);
       }
     }
   }
@@ -590,12 +603,12 @@
   // was obtained by dropping the eigenvector corresponding to this
   // eigenvalue.
   double expected_covariance[] = {
-     5.4135e-02,  -3.5121e-02,   1.7257e-04,   3.4514e-04,   5.1771e-04,  -1.6076e-02,
-    -3.5121e-02,   3.8667e-02,  -1.9288e-03,  -3.8576e-03,  -5.7864e-03,   1.2549e-02,
-     1.7257e-04,  -1.9288e-03,   2.3235e-01,  -3.5297e-02,  -5.2946e-02,  -3.3329e-04,
-     3.4514e-04,  -3.8576e-03,  -3.5297e-02,   1.7941e-01,  -1.0589e-01,  -6.6659e-04,
-     5.1771e-04,  -5.7864e-03,  -5.2946e-02,  -1.0589e-01,   9.1162e-02,  -9.9988e-04,
-    -1.6076e-02,   1.2549e-02,  -3.3329e-04,  -6.6659e-04,  -9.9988e-04,   3.9539e-02
+     5.4135e-02,  -3.5121e-02,   1.7257e-04,   3.4514e-04,   5.1771e-04,  -1.6076e-02,  // NOLINT
+    -3.5121e-02,   3.8667e-02,  -1.9288e-03,  -3.8576e-03,  -5.7864e-03,   1.2549e-02,  // NOLINT
+     1.7257e-04,  -1.9288e-03,   2.3235e-01,  -3.5297e-02,  -5.2946e-02,  -3.3329e-04,  // NOLINT
+     3.4514e-04,  -3.8576e-03,  -3.5297e-02,   1.7941e-01,  -1.0589e-01,  -6.6659e-04,  // NOLINT
+     5.1771e-04,  -5.7864e-03,  -5.2946e-02,  -1.0589e-01,   9.1162e-02,  -9.9988e-04,  // NOLINT
+    -1.6076e-02,   1.2549e-02,  -3.3329e-04,  -6.6659e-04,  -9.9988e-04,   3.9539e-02   // NOLINT
   };
 
 
@@ -637,7 +650,9 @@
 
     {
       double jacobian = 5.0;
-      problem_.AddResidualBlock(new UnaryCostFunction(1, 1, &jacobian), NULL, z);
+      problem_.AddResidualBlock(new UnaryCostFunction(1, 1, &jacobian),
+                                NULL,
+                                z);
     }
 
     {
@@ -715,7 +730,8 @@
   virtual void SetUp() {
     num_parameter_blocks_ = 2000;
     parameter_block_size_ = 5;
-    parameters_.reset(new double[parameter_block_size_ * num_parameter_blocks_]);
+    parameters_.reset(
+        new double[parameter_block_size_ * num_parameter_blocks_]);
 
     Matrix jacobian(parameter_block_size_, parameter_block_size_);
     for (int i = 0; i < num_parameter_blocks_; ++i) {
diff --git a/internal/ceres/cxsparse.cc b/internal/ceres/cxsparse.cc
index 87503d0..cf39518 100644
--- a/internal/ceres/cxsparse.cc
+++ b/internal/ceres/cxsparse.cc
@@ -38,13 +38,14 @@
 #include <vector>
 #include "ceres/compressed_col_sparse_matrix_utils.h"
 #include "ceres/compressed_row_sparse_matrix.h"
-#include "ceres/internal/port.h"
 #include "ceres/triplet_sparse_matrix.h"
 #include "glog/logging.h"
 
 namespace ceres {
 namespace internal {
 
+using std::vector;
+
 CXSparse::CXSparse() : scratch_(NULL), scratch_size_(0) {
 }
 
@@ -128,7 +129,7 @@
 
   int* ordering = cs_amd(1, &block_matrix);
   vector<int> block_ordering(num_row_blocks, -1);
-  copy(ordering, ordering + num_row_blocks, &block_ordering[0]);
+  std::copy(ordering, ordering + num_row_blocks, &block_ordering[0]);
   cs_free(ordering);
 
   vector<int> scalar_ordering;
@@ -191,7 +192,7 @@
 
 void CXSparse::ApproximateMinimumDegreeOrdering(cs_di* A, int* ordering) {
   int* cs_ordering = cs_amd(1, A);
-  copy(cs_ordering, cs_ordering + A->m, ordering);
+  std::copy(cs_ordering, cs_ordering + A->m, ordering);
   cs_free(cs_ordering);
 }
 
diff --git a/internal/ceres/cxsparse.h b/internal/ceres/cxsparse.h
index 5868401..907bc51 100644
--- a/internal/ceres/cxsparse.h
+++ b/internal/ceres/cxsparse.h
@@ -107,8 +107,8 @@
   // The returned matrix should be deallocated with Free when not used
   // anymore.
   cs_dis* BlockAnalyzeCholesky(cs_di* A,
-                               const vector<int>& row_blocks,
-                               const vector<int>& col_blocks);
+                               const std::vector<int>& row_blocks,
+                               const std::vector<int>& col_blocks);
 
   // Compute an fill-reducing approximate minimum degree ordering of
   // the matrix A. ordering should be non-NULL and should point to
@@ -133,8 +133,7 @@
 
 class CXSparse {
  public:
-  void Free(void*) {};
-
+  void Free(void* arg) {}
 };
 #endif  // CERES_NO_CXSPARSE
 
diff --git a/internal/ceres/dogleg_strategy.cc b/internal/ceres/dogleg_strategy.cc
index f29376d..a88c7e9 100644
--- a/internal/ceres/dogleg_strategy.cc
+++ b/internal/ceres/dogleg_strategy.cc
@@ -120,7 +120,8 @@
   //
   jacobian->SquaredColumnNorm(diagonal_.data());
   for (int i = 0; i < n; ++i) {
-    diagonal_[i] = min(max(diagonal_[i], min_diagonal_), max_diagonal_);
+    diagonal_[i] = std::min(std::max(diagonal_[i], min_diagonal_),
+                            max_diagonal_);
   }
   diagonal_ = diagonal_.array().sqrt();
 
@@ -618,13 +619,13 @@
   }
 
   if (step_quality > increase_threshold_) {
-    radius_ = max(radius_, 3.0 * dogleg_step_norm_);
+    radius_ = std::max(radius_, 3.0 * dogleg_step_norm_);
   }
 
   // Reduce the regularization multiplier, in the hope that whatever
   // was causing the rank deficiency has gone away and we can return
   // to doing a pure Gauss-Newton solve.
-  mu_ = max(min_mu_, 2.0 * mu_ / mu_increase_factor_);
+  mu_ = std::max(min_mu_, 2.0 * mu_ / mu_increase_factor_);
   reuse_ = false;
 }
 
diff --git a/internal/ceres/dogleg_strategy_test.cc b/internal/ceres/dogleg_strategy_test.cc
index 795719d..45128a5 100644
--- a/internal/ceres/dogleg_strategy_test.cc
+++ b/internal/ceres/dogleg_strategy_test.cc
@@ -63,12 +63,12 @@
   virtual void SetUp() {
     Matrix basis(6, 6);
     // The following lines exceed 80 characters for better readability.
-    basis << -0.1046920933796121, -0.7449367449921986, -0.4190744502875876, -0.4480450716142566,  0.2375351607929440, -0.0363053418882862,
-              0.4064975684355914,  0.2681113508511354, -0.7463625494601520, -0.0803264850508117, -0.4463149623021321,  0.0130224954867195,
-             -0.5514387729089798,  0.1026621026168657, -0.5008316122125011,  0.5738122212666414,  0.2974664724007106,  0.1296020877535158,
-              0.5037835370947156,  0.2668479925183712, -0.1051754618492798, -0.0272739396578799,  0.7947481647088278, -0.1776623363955670,
-             -0.4005458426625444,  0.2939330589634109, -0.0682629380550051, -0.2895448882503687, -0.0457239396341685, -0.8139899477847840,
-             -0.3247764582762654,  0.4528151365941945, -0.0276683863102816, -0.6155994592510784,  0.1489240599972848,  0.5362574892189350;
+    basis << -0.1046920933796121, -0.7449367449921986, -0.4190744502875876, -0.4480450716142566,  0.2375351607929440, -0.0363053418882862,  // NOLINT
+              0.4064975684355914,  0.2681113508511354, -0.7463625494601520, -0.0803264850508117, -0.4463149623021321,  0.0130224954867195,  // NOLINT
+             -0.5514387729089798,  0.1026621026168657, -0.5008316122125011,  0.5738122212666414,  0.2974664724007106,  0.1296020877535158,  // NOLINT
+              0.5037835370947156,  0.2668479925183712, -0.1051754618492798, -0.0272739396578799,  0.7947481647088278, -0.1776623363955670,  // NOLINT
+             -0.4005458426625444,  0.2939330589634109, -0.0682629380550051, -0.2895448882503687, -0.0457239396341685, -0.8139899477847840,  // NOLINT
+             -0.3247764582762654,  0.4528151365941945, -0.0276683863102816, -0.6155994592510784,  0.1489240599972848,  0.5362574892189350;  // NOLINT
 
     Vector Ddiag(6);
     Ddiag << 1.0, 2.0, 4.0, 8.0, 16.0, 32.0;
diff --git a/internal/ceres/dynamic_autodiff_cost_function_test.cc b/internal/ceres/dynamic_autodiff_cost_function_test.cc
index 42d6ab7..4e4faf9 100644
--- a/internal/ceres/dynamic_autodiff_cost_function_test.cc
+++ b/internal/ceres/dynamic_autodiff_cost_function_test.cc
@@ -39,6 +39,8 @@
 namespace ceres {
 namespace internal {
 
+using std::vector;
+
 // Takes 2 parameter blocks:
 //     parameters[0] is size 10.
 //     parameters[1] is size 5.
@@ -212,7 +214,7 @@
   }
 }
 
-TEST(DynamicAutodiffCostFunctionTest, JacobianWithSecondParameterBlockConstant) {
+TEST(DynamicAutodiffCostFunctionTest, JacobianWithSecondParameterBlockConstant) {  // NOLINT
   // Test the residual counting.
   vector<double> param_block_0(10, 0.0);
   for (int i = 0; i < 10; ++i) {
diff --git a/internal/ceres/dynamic_compressed_row_finalizer.h b/internal/ceres/dynamic_compressed_row_finalizer.h
index 5e6b0d8..70c7d63 100644
--- a/internal/ceres/dynamic_compressed_row_finalizer.h
+++ b/internal/ceres/dynamic_compressed_row_finalizer.h
@@ -48,4 +48,4 @@
 }  // namespace internal
 }  // namespace ceres
 
-#endif // CERES_INTERNAL_DYNAMIC_COMPRESED_ROW_FINALISER_H_
+#endif  // CERES_INTERNAL_DYNAMIC_COMPRESED_ROW_FINALISER_H_
diff --git a/internal/ceres/dynamic_compressed_row_jacobian_writer.cc b/internal/ceres/dynamic_compressed_row_jacobian_writer.cc
index b46cb79..24dfdab 100644
--- a/internal/ceres/dynamic_compressed_row_jacobian_writer.cc
+++ b/internal/ceres/dynamic_compressed_row_jacobian_writer.cc
@@ -39,6 +39,9 @@
 namespace ceres {
 namespace internal {
 
+using std::pair;
+using std::vector;
+
 ScratchEvaluatePreparer*
 DynamicCompressedRowJacobianWriter::CreateEvaluatePreparers(int num_threads) {
   return ScratchEvaluatePreparer::Create(*program_, num_threads);
diff --git a/internal/ceres/dynamic_compressed_row_jacobian_writer.h b/internal/ceres/dynamic_compressed_row_jacobian_writer.h
index df9581b..3d7d5e6 100644
--- a/internal/ceres/dynamic_compressed_row_jacobian_writer.h
+++ b/internal/ceres/dynamic_compressed_row_jacobian_writer.h
@@ -80,4 +80,4 @@
 }  // namespace internal
 }  // namespace ceres
 
-#endif // CERES_INTERNAL_DYNAMIC_COMPRESSED_ROW_JACOBIAN_WRITER_H_
+#endif  // CERES_INTERNAL_DYNAMIC_COMPRESSED_ROW_JACOBIAN_WRITER_H_
diff --git a/internal/ceres/dynamic_compressed_row_sparse_matrix.h b/internal/ceres/dynamic_compressed_row_sparse_matrix.h
index 7a89a70..4a2ddd6 100644
--- a/internal/ceres/dynamic_compressed_row_sparse_matrix.h
+++ b/internal/ceres/dynamic_compressed_row_sparse_matrix.h
@@ -41,6 +41,8 @@
 #ifndef CERES_INTERNAL_DYNAMIC_COMPRESSED_ROW_SPARSE_MATRIX_H_
 #define CERES_INTERNAL_DYNAMIC_COMPRESSED_ROW_SPARSE_MATRIX_H_
 
+#include <vector>
+
 #include "ceres/compressed_row_sparse_matrix.h"
 
 namespace ceres {
@@ -89,11 +91,11 @@
   void Finalize(int num_additional_elements);
 
  private:
-  vector<vector<int> > dynamic_cols_;
-  vector<vector<double> > dynamic_values_;
+  std::vector<std::vector<int> > dynamic_cols_;
+  std::vector<std::vector<double> > dynamic_values_;
 };
 
 }  // namespace internal
 }  // namespace ceres
 
-#endif // CERES_INTERNAL_DYNAMIC_COMPRESSED_ROW_SPARSE_MATRIX_H_
+#endif  // CERES_INTERNAL_DYNAMIC_COMPRESSED_ROW_SPARSE_MATRIX_H_
diff --git a/internal/ceres/dynamic_compressed_row_sparse_matrix_test.cc b/internal/ceres/dynamic_compressed_row_sparse_matrix_test.cc
index 03bfcb6..bc1de72 100644
--- a/internal/ceres/dynamic_compressed_row_sparse_matrix_test.cc
+++ b/internal/ceres/dynamic_compressed_row_sparse_matrix_test.cc
@@ -32,7 +32,6 @@
 
 #include "ceres/casts.h"
 #include "ceres/compressed_row_sparse_matrix.h"
-#include "ceres/casts.h"
 #include "ceres/internal/eigen.h"
 #include "ceres/internal/scoped_ptr.h"
 #include "ceres/linear_least_squares_problems.h"
@@ -42,6 +41,9 @@
 namespace ceres {
 namespace internal {
 
+using std::vector;
+using std::copy;
+
 class DynamicCompressedRowSparseMatrixTest : public ::testing::Test {
  protected:
   virtual void SetUp() {
@@ -53,7 +55,7 @@
     // Set this to some nonzero value to be sure.
     num_additional_elements = 13;
 
-    expected_num_nonzeros = num_rows * num_cols - min(num_rows, num_cols);
+    expected_num_nonzeros = num_rows * num_cols - std::min(num_rows, num_cols);
 
     InitialiseDenseReference();
     InitialiseSparseMatrixReferences();
@@ -82,8 +84,8 @@
   }
 
   void InitialiseSparseMatrixReferences() {
-    std::vector<int> rows, cols;
-    std::vector<double> values;
+    vector<int> rows, cols;
+    vector<double> values;
     for (int i = 0; i < (num_rows * num_cols); ++i) {
       const int r = i / num_cols, c = i % num_cols;
       if (r != c) {
@@ -97,9 +99,9 @@
     tsm.reset(new TripletSparseMatrix(num_rows,
                                       num_cols,
                                       expected_num_nonzeros));
-    std::copy(rows.begin(), rows.end(), tsm->mutable_rows());
-    std::copy(cols.begin(), cols.end(), tsm->mutable_cols());
-    std::copy(values.begin(), values.end(), tsm->mutable_values());
+    copy(rows.begin(), rows.end(), tsm->mutable_rows());
+    copy(cols.begin(), cols.end(), tsm->mutable_cols());
+    copy(values.begin(), values.end(), tsm->mutable_values());
     tsm->set_num_nonzeros(values.size());
 
     Matrix dense_from_tsm;
diff --git a/internal/ceres/dynamic_numeric_diff_cost_function_test.cc b/internal/ceres/dynamic_numeric_diff_cost_function_test.cc
index 19f4d88..6d1f362 100644
--- a/internal/ceres/dynamic_numeric_diff_cost_function_test.cc
+++ b/internal/ceres/dynamic_numeric_diff_cost_function_test.cc
@@ -38,6 +38,8 @@
 namespace ceres {
 namespace internal {
 
+using std::vector;
+
 const double kTolerance = 1e-6;
 
 // Takes 2 parameter blocks:
diff --git a/internal/ceres/evaluator.h b/internal/ceres/evaluator.h
index 8fc60b8..7fec1ee 100644
--- a/internal/ceres/evaluator.h
+++ b/internal/ceres/evaluator.h
@@ -95,8 +95,8 @@
   static bool Evaluate(Program* program,
                        int num_threads,
                        double* cost,
-                       vector<double>* residuals,
-                       vector<double>* gradient,
+                       std::vector<double>* residuals,
+                       std::vector<double>* gradient,
                        CRSMatrix* jacobian);
 
   // Build and return a sparse matrix for storing and working with the Jacobian
@@ -190,12 +190,12 @@
   // that the base class implementation does not have to worry about
   // life time issues. Further, these calls are not expected to be
   // frequent or performance sensitive.
-  virtual map<string, int> CallStatistics() const {
-    return map<string, int>();
+  virtual std::map<string, int> CallStatistics() const {
+    return std::map<string, int>();
   }
 
-  virtual map<string, double> TimeStatistics() const {
-    return map<string, double>();
+  virtual std::map<string, double> TimeStatistics() const {
+    return std::map<string, double>();
   }
 };
 
diff --git a/internal/ceres/evaluator_test.cc b/internal/ceres/evaluator_test.cc
index c0de3fc..ddfafd9 100644
--- a/internal/ceres/evaluator_test.cc
+++ b/internal/ceres/evaluator_test.cc
@@ -51,6 +51,8 @@
 namespace ceres {
 namespace internal {
 
+using std::vector;
+
 // TODO(keir): Consider pushing this into a common test utils file.
 template<int kFactor, int kNumResiduals,
          int N0 = 0, int N1 = 0, int N2 = 0, bool kSucceeds = true>
diff --git a/internal/ceres/execution_summary.h b/internal/ceres/execution_summary.h
index 29bdc69..3f684f9 100644
--- a/internal/ceres/execution_summary.h
+++ b/internal/ceres/execution_summary.h
@@ -56,15 +56,15 @@
     calls_[name] += 1;
   }
 
-  const map<string, double>& times() const { return times_; }
-  const map<string, int>& calls() const { return calls_; }
+  const std::map<string, double>& times() const { return times_; }
+  const std::map<string, int>& calls() const { return calls_; }
 
  private:
   Mutex times_mutex_;
-  map<string, double> times_;
+  std::map<string, double> times_;
 
   Mutex calls_mutex_;
-  map<string, int> calls_;
+  std::map<string, int> calls_;
 };
 
 class ScopedExecutionTimer {
diff --git a/internal/ceres/gradient_checker_test.cc b/internal/ceres/gradient_checker_test.cc
index fa0d841..aa60fdc 100644
--- a/internal/ceres/gradient_checker_test.cc
+++ b/internal/ceres/gradient_checker_test.cc
@@ -44,6 +44,8 @@
 namespace ceres {
 namespace internal {
 
+using std::vector;
+
 // We pick a (non-quadratic) function whose derivative are easy:
 //
 //    f = exp(- a' x).
diff --git a/internal/ceres/gradient_checking_cost_function.cc b/internal/ceres/gradient_checking_cost_function.cc
index 3272848..52b649b 100644
--- a/internal/ceres/gradient_checking_cost_function.cc
+++ b/internal/ceres/gradient_checking_cost_function.cc
@@ -51,6 +51,9 @@
 
 namespace ceres {
 namespace internal {
+
+using std::vector;
+
 namespace {
 
 // True if x and y have an absolute relative difference less than
@@ -68,7 +71,7 @@
     relative_error = &local_relative_error;
   }
   *absolute_error = fabs(x - y);
-  *relative_error = *absolute_error / max(fabs(x), fabs(y));
+  *relative_error = *absolute_error / std::max(fabs(x), fabs(y));
   if (x == 0 || y == 0) {
     // If x or y is exactly zero, then relative difference doesn't have any
     // meaning. Take the absolute difference instead.
@@ -121,7 +124,8 @@
     vector<Matrix> term_jacobians(block_sizes.size());
     vector<Matrix> finite_difference_jacobians(block_sizes.size());
     vector<double*> term_jacobian_pointers(block_sizes.size());
-    vector<double*> finite_difference_jacobian_pointers(block_sizes.size());
+    vector<double*> finite_difference_jacobian_pointers(
+        block_sizes.size());
     for (int i = 0; i < block_sizes.size(); i++) {
       term_jacobians[i].resize(num_residuals, block_sizes[i]);
       term_jacobian_pointers[i] = term_jacobians[i].data();
@@ -259,7 +263,8 @@
 
   // For every ParameterBlock in problem_impl, create a new parameter
   // block with the same local parameterization and constancy.
-  const vector<ParameterBlock*>& parameter_blocks = program->parameter_blocks();
+  const vector<ParameterBlock*>& parameter_blocks =
+      program->parameter_blocks();
   for (int i = 0; i < parameter_blocks.size(); ++i) {
     ParameterBlock* parameter_block = parameter_blocks[i];
     gradient_checking_problem_impl->AddParameterBlock(
@@ -276,7 +281,8 @@
   // For every ResidualBlock in problem_impl, create a new
   // ResidualBlock by wrapping its CostFunction inside a
   // GradientCheckingCostFunction.
-  const vector<ResidualBlock*>& residual_blocks = program->residual_blocks();
+  const vector<ResidualBlock*>& residual_blocks =
+      program->residual_blocks();
   for (int i = 0; i < residual_blocks.size(); ++i) {
     ResidualBlock* residual_block = residual_blocks[i];
 
diff --git a/internal/ceres/gradient_checking_cost_function_test.cc b/internal/ceres/gradient_checking_cost_function_test.cc
index caba2f6..7bdc4da 100644
--- a/internal/ceres/gradient_checking_cost_function_test.cc
+++ b/internal/ceres/gradient_checking_cost_function_test.cc
@@ -48,6 +48,7 @@
 #include "gmock/mock-log.h"
 #include "gtest/gtest.h"
 
+using std::vector;
 using testing::AllOf;
 using testing::AnyNumber;
 using testing::HasSubstr;
diff --git a/internal/ceres/gradient_problem_evaluator.h b/internal/ceres/gradient_problem_evaluator.h
index 20053de..7d144e3 100644
--- a/internal/ceres/gradient_problem_evaluator.h
+++ b/internal/ceres/gradient_problem_evaluator.h
@@ -79,11 +79,11 @@
 
   virtual int NumResiduals() const { return 1; }
 
-  virtual map<string, int> CallStatistics() const {
+  virtual std::map<string, int> CallStatistics() const {
     return execution_summary_.calls();
   }
 
-  virtual map<string, double> TimeStatistics() const {
+  virtual std::map<string, double> TimeStatistics() const {
     return execution_summary_.times();
   }
 
diff --git a/internal/ceres/gradient_problem_solver.cc b/internal/ceres/gradient_problem_solver.cc
index 4fda929..aea0804 100644
--- a/internal/ceres/gradient_problem_solver.cc
+++ b/internal/ceres/gradient_problem_solver.cc
@@ -155,7 +155,7 @@
     SetSummaryFinalCost(summary);
   }
 
-  const map<string, double>& evaluator_time_statistics =
+  const std::map<string, double>& evaluator_time_statistics =
        minimizer_options.evaluator->TimeStatistics();
   summary->cost_evaluation_time_in_seconds =
       FindWithDefault(evaluator_time_statistics, "Evaluator::Residual", 0.0);
@@ -199,7 +199,7 @@
                       initial_cost,
                       final_cost,
                       TerminationTypeToString(termination_type));
-};
+}
 
 string GradientProblemSolver::Summary::FullReport() const {
   using internal::VersionString;
@@ -263,7 +263,7 @@
   StringAppendF(&report, "Termination:        %25s (%s)\n",
                 TerminationTypeToString(termination_type), message.c_str());
   return report;
-};
+}
 
 void Solve(const GradientProblemSolver::Options& options,
            const GradientProblem& problem,
diff --git a/internal/ceres/graph.h b/internal/ceres/graph.h
index f639d15..c9d8514 100644
--- a/internal/ceres/graph.h
+++ b/internal/ceres/graph.h
@@ -139,9 +139,9 @@
     for (typename HashSet<Vertex>::const_iterator it = sinks.begin();
          it != sinks.end(); ++it) {
       if (vertex < *it) {
-        edge_weights_.erase(make_pair(vertex, *it));
+        edge_weights_.erase(std::make_pair(vertex, *it));
       } else {
-        edge_weights_.erase(make_pair(*it, vertex));
+        edge_weights_.erase(std::make_pair(*it, vertex));
       }
       edges_[*it].erase(vertex);
     }
@@ -165,9 +165,9 @@
     }
 
     if (vertex1 < vertex2) {
-      edge_weights_[make_pair(vertex1, vertex2)] = weight;
+      edge_weights_[std::make_pair(vertex1, vertex2)] = weight;
     } else {
-      edge_weights_[make_pair(vertex2, vertex1)] = weight;
+      edge_weights_[std::make_pair(vertex2, vertex1)] = weight;
     }
   }
 
@@ -188,9 +188,11 @@
   // the edge weight is zero.
   double EdgeWeight(const Vertex& vertex1, const Vertex& vertex2) const {
     if (vertex1 < vertex2) {
-      return FindWithDefault(edge_weights_, make_pair(vertex1, vertex2), 0.0);
+      return FindWithDefault(edge_weights_,
+                             std::make_pair(vertex1, vertex2), 0.0);
     } else {
-      return FindWithDefault(edge_weights_, make_pair(vertex2, vertex1), 0.0);
+      return FindWithDefault(edge_weights_,
+                             std::make_pair(vertex2, vertex1), 0.0);
     }
   }
 
@@ -206,13 +208,13 @@
 
   static double InvalidWeight() {
     return std::numeric_limits<double>::quiet_NaN();
-  };
+  }
 
  private:
   HashSet<Vertex> vertices_;
   HashMap<Vertex, double> vertex_weights_;
   HashMap<Vertex, HashSet<Vertex> > edges_;
-  HashMap<pair<Vertex, Vertex>, double> edge_weights_;
+  HashMap<std::pair<Vertex, Vertex>, double> edge_weights_;
 
   CERES_DISALLOW_COPY_AND_ASSIGN(WeightedGraph);
 };
diff --git a/internal/ceres/graph_algorithms.h b/internal/ceres/graph_algorithms.h
index fb75e2f..7724f8d 100644
--- a/internal/ceres/graph_algorithms.h
+++ b/internal/ceres/graph_algorithms.h
@@ -95,7 +95,7 @@
 // cardinality of S.
 template <typename Vertex>
 int IndependentSetOrdering(const Graph<Vertex>& graph,
-                           vector<Vertex>* ordering) {
+                           std::vector<Vertex>* ordering) {
   const HashSet<Vertex>& vertices = graph.vertices();
   const int num_vertices = vertices.size();
 
@@ -110,7 +110,7 @@
 
   // Mark all vertices white.
   HashMap<Vertex, char> vertex_color;
-  vector<Vertex> vertex_queue;
+  std::vector<Vertex> vertex_queue;
   for (typename HashSet<Vertex>::const_iterator it = vertices.begin();
        it != vertices.end();
        ++it) {
@@ -119,8 +119,8 @@
   }
 
 
-  sort(vertex_queue.begin(), vertex_queue.end(),
-       VertexTotalOrdering<Vertex>(graph));
+  std::sort(vertex_queue.begin(), vertex_queue.end(),
+            VertexTotalOrdering<Vertex>(graph));
 
   // Iterate over vertex_queue. Pick the first white vertex, add it
   // to the independent set. Mark it black and its neighbors grey.
@@ -145,7 +145,7 @@
   // Iterate over the vertices and add all the grey vertices to the
   // ordering. At this stage there should only be black or grey
   // vertices in the graph.
-  for (typename vector<Vertex>::const_iterator it = vertex_queue.begin();
+  for (typename std::vector<Vertex>::const_iterator it = vertex_queue.begin();
        it != vertex_queue.end();
        ++it) {
     const Vertex vertex = *it;
@@ -171,7 +171,7 @@
 // ordering algorithm over all.
 template <typename Vertex>
 int StableIndependentSetOrdering(const Graph<Vertex>& graph,
-                                 vector<Vertex>* ordering) {
+                                 std::vector<Vertex>* ordering) {
   CHECK_NOTNULL(ordering);
   const HashSet<Vertex>& vertices = graph.vertices();
   const int num_vertices = vertices.size();
@@ -182,10 +182,10 @@
   const char kGrey = 1;
   const char kBlack = 2;
 
-  vector<Vertex> vertex_queue(*ordering);
+  std::vector<Vertex> vertex_queue(*ordering);
 
-  stable_sort(vertex_queue.begin(), vertex_queue.end(),
-              VertexDegreeLessThan<Vertex>(graph));
+  std::stable_sort(vertex_queue.begin(), vertex_queue.end(),
+                  VertexDegreeLessThan<Vertex>(graph));
 
   // Mark all vertices white.
   HashMap<Vertex, char> vertex_color;
@@ -220,7 +220,7 @@
   // Iterate over the vertices and add all the grey vertices to the
   // ordering. At this stage there should only be black or grey
   // vertices in the graph.
-  for (typename vector<Vertex>::const_iterator it = vertex_queue.begin();
+  for (typename std::vector<Vertex>::const_iterator it = vertex_queue.begin();
        it != vertex_queue.end();
        ++it) {
     const Vertex vertex = *it;
@@ -274,7 +274,7 @@
 WeightedGraph<Vertex>*
 Degree2MaximumSpanningForest(const WeightedGraph<Vertex>& graph) {
   // Array of edges sorted in decreasing order of their weights.
-  vector<pair<double, pair<Vertex, Vertex> > > weighted_edges;
+  std::vector<std::pair<double, std::pair<Vertex, Vertex> > > weighted_edges;
   WeightedGraph<Vertex>* forest = new WeightedGraph<Vertex>();
 
   // Disjoint-set to keep track of the connected components in the
@@ -302,19 +302,20 @@
         continue;
       }
       const double weight = graph.EdgeWeight(vertex1, vertex2);
-      weighted_edges.push_back(make_pair(weight, make_pair(vertex1, vertex2)));
+      weighted_edges.push_back(
+          std::make_pair(weight, std::make_pair(vertex1, vertex2)));
     }
   }
 
   // The elements of this vector, are pairs<edge_weight,
   // edge>. Sorting it using the reverse iterators gives us the edges
   // in decreasing order of edges.
-  sort(weighted_edges.rbegin(), weighted_edges.rend());
+  std::sort(weighted_edges.rbegin(), weighted_edges.rend());
 
   // Greedily add edges to the spanning tree/forest as long as they do
   // not violate the degree/cycle constraint.
   for (int i =0; i < weighted_edges.size(); ++i) {
-    const pair<Vertex, Vertex>& edge = weighted_edges[i].second;
+    const std::pair<Vertex, Vertex>& edge = weighted_edges[i].second;
     const Vertex vertex1 = edge.first;
     const Vertex vertex2 = edge.second;
 
@@ -350,7 +351,7 @@
     // lookup.
     if (root2 < root1) {
       std::swap(root1, root2);
-    };
+    }
 
     disjoint_set[root2] = root1;
   }
diff --git a/internal/ceres/graph_algorithms_test.cc b/internal/ceres/graph_algorithms_test.cc
index bbb1e0d..61b9646 100644
--- a/internal/ceres/graph_algorithms_test.cc
+++ b/internal/ceres/graph_algorithms_test.cc
@@ -40,6 +40,8 @@
 namespace ceres {
 namespace internal {
 
+using std::vector;
+
 TEST(IndependentSetOrdering, Chain) {
   Graph<int> graph;
   graph.AddVertex(0);
@@ -238,7 +240,7 @@
     EXPECT_EQ(independent_set_size, 1);
     EXPECT_EQ(ordering[0], 1);
   }
-
 }
+
 }  // namespace internal
 }  // namespace ceres
diff --git a/internal/ceres/implicit_schur_complement.h b/internal/ceres/implicit_schur_complement.h
index c992bdc..99b67af 100644
--- a/internal/ceres/implicit_schur_complement.h
+++ b/internal/ceres/implicit_schur_complement.h
@@ -97,7 +97,7 @@
   //
   // TODO(sameeragarwal): Get rid of the two bools below and replace
   // them with enums.
-  ImplicitSchurComplement(const LinearSolver::Options& options);
+  explicit ImplicitSchurComplement(const LinearSolver::Options& options);
   virtual ~ImplicitSchurComplement();
 
   // Initialize the Schur complement for a linear least squares
diff --git a/internal/ceres/implicit_schur_complement_test.cc b/internal/ceres/implicit_schur_complement_test.cc
index 3369ecb..8b40da4 100644
--- a/internal/ceres/implicit_schur_complement_test.cc
+++ b/internal/ceres/implicit_schur_complement_test.cc
@@ -74,7 +74,7 @@
                                       Vector* solution) {
     const CompressedRowBlockStructure* bs = A_->block_structure();
     const int num_col_blocks = bs->cols.size();
-    vector<int> blocks(num_col_blocks - num_eliminate_blocks_, 0);
+    std::vector<int> blocks(num_col_blocks - num_eliminate_blocks_, 0);
     for (int i = num_eliminate_blocks_; i < num_col_blocks; ++i) {
       blocks[i - num_eliminate_blocks_] = bs->cols[i].size;
     }
diff --git a/internal/ceres/lapack.cc b/internal/ceres/lapack.cc
index e124d75..a3d9980 100644
--- a/internal/ceres/lapack.cc
+++ b/internal/ceres/lapack.cc
@@ -110,7 +110,7 @@
   *message = "Success";
   return LINEAR_SOLVER_SUCCESS;
 #endif
-};
+}
 
 int LAPACK::EstimateWorkSizeForQR(int num_rows, int num_cols) {
 #ifdef CERES_NO_LAPACK
diff --git a/internal/ceres/levenberg_marquardt_strategy.cc b/internal/ceres/levenberg_marquardt_strategy.cc
index ce3b69a..e47ef48 100644
--- a/internal/ceres/levenberg_marquardt_strategy.cc
+++ b/internal/ceres/levenberg_marquardt_strategy.cc
@@ -79,7 +79,8 @@
 
     jacobian->SquaredColumnNorm(diagonal_.data());
     for (int i = 0; i < num_parameters; ++i) {
-      diagonal_[i] = min(max(diagonal_[i], min_diagonal_), max_diagonal_);
+      diagonal_[i] = std::min(std::max(diagonal_[i], min_diagonal_),
+                              max_diagonal_);
     }
   }
 
diff --git a/internal/ceres/line_search.cc b/internal/ceres/line_search.cc
index 8c2624e..d9343c9 100644
--- a/internal/ceres/line_search.cc
+++ b/internal/ceres/line_search.cc
@@ -44,6 +44,11 @@
 
 namespace ceres {
 namespace internal {
+
+using std::map;
+using std::ostream;
+using std::vector;
+
 namespace {
 // Precision used for floating point values in error message output.
 const int kErrorMessageNumericPrecision = 8;
@@ -54,7 +59,7 @@
   sample.value = value;
   sample.value_is_valid = true;
   return sample;
-};
+}
 
 FunctionSample ValueAndGradientSample(const double x,
                                       const double value,
@@ -66,15 +71,15 @@
   sample.value_is_valid = true;
   sample.gradient_is_valid = true;
   return sample;
-};
+}
 
 }  // namespace
 
 
-std::ostream& operator<<(std::ostream &os, const FunctionSample& sample);
+ostream& operator<<(ostream &os, const FunctionSample& sample);
 
 // Convenience stream operator for pushing FunctionSamples into log messages.
-std::ostream& operator<<(std::ostream &os, const FunctionSample& sample) {
+ostream& operator<<(ostream &os, const FunctionSample& sample) {
   os << sample.ToDebugString();
   return os;
 }
@@ -208,7 +213,7 @@
        max_step_size <= current.x)) {
     // Either: sample is invalid; or we are using BISECTION and contracting
     // the step size.
-    return min(max(current.x * 0.5, min_step_size), max_step_size);
+    return std::min(std::max(current.x * 0.5, min_step_size), max_step_size);
   } else if (interpolation_type == BISECTION) {
     CHECK_GT(max_step_size, current.x);
     // We are expanding the search (during a Wolfe bracketing phase) using
diff --git a/internal/ceres/line_search_direction.cc b/internal/ceres/line_search_direction.cc
index dddcecd..2d86c22 100644
--- a/internal/ceres/line_search_direction.cc
+++ b/internal/ceres/line_search_direction.cc
@@ -86,7 +86,7 @@
       LOG(WARNING) << "Restarting non-linear conjugate gradients: "
                    << directional_derivative;
       *search_direction = -current.gradient;
-    };
+    }
 
     return true;
   }
diff --git a/internal/ceres/line_search_minimizer.cc b/internal/ceres/line_search_minimizer.cc
index d36545d..85cc031 100644
--- a/internal/ceres/line_search_minimizer.cc
+++ b/internal/ceres/line_search_minimizer.cc
@@ -290,9 +290,9 @@
     // iteration.
     const double initial_step_size =
         (iteration_summary.iteration == 1 || !line_search_status)
-        ? min(1.0, 1.0 / current_state.gradient_max_norm)
-        : min(1.0, 2.0 * (current_state.cost - previous_state.cost) /
-              current_state.directional_derivative);
+        ? std::min(1.0, 1.0 / current_state.gradient_max_norm)
+        : std::min(1.0, 2.0 * (current_state.cost - previous_state.cost) /
+                   current_state.directional_derivative);
     // By definition, we should only ever go forwards along the specified search
     // direction in a line search, most likely cause for this being violated
     // would be a numerical failure in the line search direction calculation.
diff --git a/internal/ceres/linear_least_squares_problems.cc b/internal/ceres/linear_least_squares_problems.cc
index 24ba565..b6a6a8c 100644
--- a/internal/ceres/linear_least_squares_problems.cc
+++ b/internal/ceres/linear_least_squares_problems.cc
@@ -97,11 +97,11 @@
   int counter = 0;
   for (int i = 0; i < 3; ++i) {
     for (int j = 0; j< 2; ++j) {
-      Ai[counter]=i;
-      Aj[counter]=j;
+      Ai[counter] = i;
+      Aj[counter] = j;
       ++counter;
     }
-  };
+  }
 
   Ax[0] = 1.;
   Ax[1] = 2.;
@@ -527,7 +527,7 @@
     LOG(INFO) << "x: \n" << ConstVectorRef(x, A->num_cols());
   }
   return true;
-};
+}
 
 void WriteArrayToFileOrDie(const string& filename,
                            const double* x,
@@ -619,7 +619,7 @@
                                                      num_eliminate_blocks);
     default:
       LOG(FATAL) << "Unknown DumpFormatType " << dump_format_type;
-  };
+  }
 
   return true;
 }
diff --git a/internal/ceres/linear_solver.h b/internal/ceres/linear_solver.h
index 5f59765..14f171c 100644
--- a/internal/ceres/linear_solver.h
+++ b/internal/ceres/linear_solver.h
@@ -144,7 +144,7 @@
     // elimination group must form an independent set in the normal
     // equations. The first elimination group corresponds to the
     // num_eliminate_blocks in the Schur type solvers.
-    vector<int> elimination_groups;
+    std::vector<int> elimination_groups;
 
     // Iterative solvers, e.g. Preconditioned Conjugate Gradients
     // maintain a cheap estimate of the residual which may become
@@ -296,12 +296,12 @@
   // that the base class implementation does not have to worry about
   // life time issues. Further, these calls are not expected to be
   // frequent or performance sensitive.
-  virtual map<string, int> CallStatistics() const {
-    return map<string, int>();
+  virtual std::map<string, int> CallStatistics() const {
+    return std::map<string, int>();
   }
 
-  virtual map<string, double> TimeStatistics() const {
-    return map<string, double>();
+  virtual std::map<string, double> TimeStatistics() const {
+    return std::map<string, double>();
   }
 
   // Factory
@@ -331,11 +331,11 @@
     return SolveImpl(down_cast<MatrixType*>(A), b, per_solve_options, x);
   }
 
-  virtual map<string, int> CallStatistics() const {
+  virtual std::map<string, int> CallStatistics() const {
     return execution_summary_.calls();
   }
 
-  virtual map<string, double> TimeStatistics() const {
+  virtual std::map<string, double> TimeStatistics() const {
     return execution_summary_.times();
   }
 
diff --git a/internal/ceres/local_parameterization.cc b/internal/ceres/local_parameterization.cc
index a4832c5..3d2e9d6 100644
--- a/internal/ceres/local_parameterization.cc
+++ b/internal/ceres/local_parameterization.cc
@@ -36,6 +36,8 @@
 
 namespace ceres {
 
+using std::vector;
+
 LocalParameterization::~LocalParameterization() {
 }
 
diff --git a/internal/ceres/local_parameterization_test.cc b/internal/ceres/local_parameterization_test.cc
index 6e7e87b..6d52e4f 100644
--- a/internal/ceres/local_parameterization_test.cc
+++ b/internal/ceres/local_parameterization_test.cc
@@ -71,7 +71,7 @@
 }
 
 TEST(SubsetParameterization, DeathTests) {
-  vector<int> constant_parameters;
+  std::vector<int> constant_parameters;
   EXPECT_DEATH_IF_SUPPORTED(
       SubsetParameterization parameterization(1, constant_parameters),
       "at least");
@@ -98,7 +98,7 @@
 
   double x[kGlobalSize] = {1.0, 2.0, 3.0, 4.0};
   for (int i = 0; i < kGlobalSize; ++i) {
-    vector<int> constant_parameters;
+    std::vector<int> constant_parameters;
     constant_parameters.push_back(i);
     SubsetParameterization parameterization(kGlobalSize, constant_parameters);
     double delta[kLocalSize] = {1.0, 2.0, 3.0};
@@ -146,7 +146,7 @@
     Matrix expected_local_matrix =
         global_matrix * MatrixRef(jacobian, kGlobalSize, kLocalSize);
     EXPECT_EQ((local_matrix - expected_local_matrix).norm(), 0.0);
-  };
+  }
 }
 
 // Functor needed to implement automatically differentiated Plus for
diff --git a/internal/ceres/low_rank_inverse_hessian.cc b/internal/ceres/low_rank_inverse_hessian.cc
index 4816e3c..3a20c9b 100644
--- a/internal/ceres/low_rank_inverse_hessian.cc
+++ b/internal/ceres/low_rank_inverse_hessian.cc
@@ -37,6 +37,8 @@
 namespace ceres {
 namespace internal {
 
+using std::list;
+
 // The (L)BFGS algorithm explicitly requires that the secant equation:
 //
 //   B_{k+1} * s_k = y_k
@@ -126,7 +128,7 @@
   const int num_corrections = indices_.size();
   Vector alpha(num_corrections);
 
-  for (std::list<int>::const_reverse_iterator it = indices_.rbegin();
+  for (list<int>::const_reverse_iterator it = indices_.rbegin();
        it != indices_.rend();
        ++it) {
     const double alpha_i = delta_x_history_.col(*it).dot(search_direction) /
@@ -173,7 +175,7 @@
             << "approximation.";
   }
 
-  for (std::list<int>::const_iterator it = indices_.begin();
+  for (list<int>::const_iterator it = indices_.begin();
        it != indices_.end();
        ++it) {
     const double beta = delta_gradient_history_.col(*it).dot(search_direction) /
diff --git a/internal/ceres/map_util.h b/internal/ceres/map_util.h
index 929c6b3..9ba81e5 100644
--- a/internal/ceres/map_util.h
+++ b/internal/ceres/map_util.h
@@ -87,8 +87,8 @@
     Collection * const collection,
     const typename Collection::value_type::first_type& key,
     const typename Collection::value_type::second_type& value) {
-  pair<typename Collection::iterator, bool> ret =
-    collection->insert(typename Collection::value_type(key, value));
+  std::pair<typename Collection::iterator, bool> ret =
+      collection->insert(typename Collection::value_type(key, value));
   return ret.second;
 }
 
diff --git a/internal/ceres/minimizer.cc b/internal/ceres/minimizer.cc
index 558921b..50fbef7 100644
--- a/internal/ceres/minimizer.cc
+++ b/internal/ceres/minimizer.cc
@@ -68,7 +68,8 @@
       return true;
     case SOLVER_TERMINATE_SUCCESSFULLY:
       summary->termination_type = USER_SUCCESS;
-      summary->message = "User callback returned SOLVER_TERMINATE_SUCCESSFULLY.";
+      summary->message =
+          "User callback returned SOLVER_TERMINATE_SUCCESSFULLY.";
       VLOG_IF(1, is_not_silent) << "Terminating: " << summary->message;
       return false;
     case SOLVER_ABORT:
diff --git a/internal/ceres/minimizer.h b/internal/ceres/minimizer.h
index dabf07e..24c8e67 100644
--- a/internal/ceres/minimizer.h
+++ b/internal/ceres/minimizer.h
@@ -132,7 +132,7 @@
     bool jacobi_scaling;
     bool use_nonmonotonic_steps;
     int max_consecutive_nonmonotonic_steps;
-    vector<int> trust_region_minimizer_iterations_to_dump;
+    std::vector<int> trust_region_minimizer_iterations_to_dump;
     DumpFormatType trust_region_problem_dump_format_type;
     string trust_region_problem_dump_directory;
     int max_num_consecutive_invalid_steps;
@@ -163,7 +163,7 @@
     // of each iteration.
     //
     // The Options struct does not own these pointers.
-    vector<IterationCallback*> callbacks;
+    std::vector<IterationCallback*> callbacks;
 
     // Object responsible for evaluating the cost, residuals and
     // Jacobian matrix.
diff --git a/internal/ceres/ordered_groups_test.cc b/internal/ceres/ordered_groups_test.cc
index 9e16c1d..09569e1 100644
--- a/internal/ceres/ordered_groups_test.cc
+++ b/internal/ceres/ordered_groups_test.cc
@@ -166,7 +166,7 @@
   ordering.AddElementToGroup(x + 1, 2);
   ordering.AddElementToGroup(x + 2, 2);
 
-  vector<double*> elements_to_remove;
+  std::vector<double*> elements_to_remove;
   elements_to_remove.push_back(x);
   elements_to_remove.push_back(x + 2);
 
@@ -181,7 +181,7 @@
   ParameterBlockOrdering ordering;
 
   double x[3];
-  vector<double*> elements_to_remove;
+  std::vector<double*> elements_to_remove;
   elements_to_remove.push_back(x);
   elements_to_remove.push_back(x + 2);
 
diff --git a/internal/ceres/parameter_block.h b/internal/ceres/parameter_block.h
index 7bc823d..1ef8673 100644
--- a/internal/ceres/parameter_block.h
+++ b/internal/ceres/parameter_block.h
@@ -193,7 +193,7 @@
     }
 
     upper_bounds_[index] = upper_bound;
-  };
+  }
 
   void SetLowerBound(int index, double lower_bound) {
     CHECK_LT(index, size_);
diff --git a/internal/ceres/parameter_block_ordering.cc b/internal/ceres/parameter_block_ordering.cc
index 1525de9..2df6988 100644
--- a/internal/ceres/parameter_block_ordering.cc
+++ b/internal/ceres/parameter_block_ordering.cc
@@ -43,6 +43,10 @@
 namespace ceres {
 namespace internal {
 
+using std::map;
+using std::set;
+using std::vector;
+
 int ComputeStableSchurOrdering(const Program& program,
                          vector<ParameterBlock*>* ordering) {
   CHECK_NOTNULL(ordering)->clear();
diff --git a/internal/ceres/parameter_block_ordering.h b/internal/ceres/parameter_block_ordering.h
index 5de9951..5a923e9 100644
--- a/internal/ceres/parameter_block_ordering.h
+++ b/internal/ceres/parameter_block_ordering.h
@@ -56,13 +56,13 @@
 //             complement of the independent set,
 //             fixed blocks]
 int ComputeSchurOrdering(const Program& program,
-                         vector<ParameterBlock* >* ordering);
+                         std::vector<ParameterBlock* >* ordering);
 
 // Same as above, except that ties while computing the independent set
 // ordering are resolved in favour of the order in which the parameter
 // blocks occur in the program.
 int ComputeStableSchurOrdering(const Program& program,
-                               vector<ParameterBlock* >* ordering);
+                               std::vector<ParameterBlock* >* ordering);
 
 // Use an approximate independent set ordering to decompose the
 // parameter blocks of a problem in a sequence of independent
@@ -81,7 +81,7 @@
 // Iterate over each of the groups in order of their priority and fill
 // summary with their sizes.
 void OrderingToGroupSizes(const ParameterBlockOrdering* ordering,
-                          vector<int>* group_sizes);
+                          std::vector<int>* group_sizes);
 
 }  // namespace internal
 }  // namespace ceres
diff --git a/internal/ceres/parameter_block_ordering_test.cc b/internal/ceres/parameter_block_ordering_test.cc
index bc497d0..dfc7b20 100644
--- a/internal/ceres/parameter_block_ordering_test.cc
+++ b/internal/ceres/parameter_block_ordering_test.cc
@@ -45,6 +45,8 @@
 namespace ceres {
 namespace internal {
 
+using std::vector;
+
 typedef Graph<ParameterBlock*> HessianGraph;
 typedef HashSet<ParameterBlock*> VertexSet;
 
@@ -82,7 +84,8 @@
 
 TEST_F(SchurOrderingTest, NoFixed) {
   const Program& program = problem_.program();
-  const vector<ParameterBlock*>& parameter_blocks = program.parameter_blocks();
+  const vector<ParameterBlock*>& parameter_blocks =
+      program.parameter_blocks();
   scoped_ptr<HessianGraph> graph(CreateHessianGraph(program));
 
   const VertexSet& vertices = graph->vertices();
@@ -136,7 +139,8 @@
   problem_.SetParameterBlockConstant(x_);
 
   const Program& program = problem_.program();
-  const vector<ParameterBlock*>& parameter_blocks = program.parameter_blocks();
+  const vector<ParameterBlock*>& parameter_blocks =
+      program.parameter_blocks();
   scoped_ptr<HessianGraph> graph(CreateHessianGraph(program));
 
   const VertexSet& vertices = graph->vertices();
diff --git a/internal/ceres/parameter_block_test.cc b/internal/ceres/parameter_block_test.cc
index 5a2db3c..f01e0ad 100644
--- a/internal/ceres/parameter_block_test.cc
+++ b/internal/ceres/parameter_block_test.cc
@@ -41,7 +41,7 @@
   ParameterBlock parameter_block(x, 3, -1);
 
   // The indices to set constant within the parameter block (used later).
-  vector<int> indices;
+  std::vector<int> indices;
   indices.push_back(1);
 
   // Can't set the parameterization if the sizes don't match.
diff --git a/internal/ceres/partitioned_matrix_view_impl.h b/internal/ceres/partitioned_matrix_view_impl.h
index ae7f776..ff041b9 100644
--- a/internal/ceres/partitioned_matrix_view_impl.h
+++ b/internal/ceres/partitioned_matrix_view_impl.h
@@ -61,7 +61,7 @@
   // explicit_schur_complement_solver.h
   num_row_blocks_e_ = 0;
   for (int r = 0; r < bs->rows.size(); ++r) {
-    const vector<Cell>& cells = bs->rows[r].cells;
+    const std::vector<Cell>& cells = bs->rows[r].cells;
     if (cells[0].block_id < num_col_blocks_e_) {
       ++num_row_blocks_e_;
     }
@@ -131,7 +131,7 @@
   for (int r = 0; r < num_row_blocks_e_; ++r) {
     const int row_block_pos = bs->rows[r].block.position;
     const int row_block_size = bs->rows[r].block.size;
-    const vector<Cell>& cells = bs->rows[r].cells;
+    const std::vector<Cell>& cells = bs->rows[r].cells;
     for (int c = 1; c < cells.size(); ++c) {
       const int col_block_id = cells[c].block_id;
       const int col_block_pos = bs->cols[col_block_id].position;
@@ -146,7 +146,7 @@
   for (int r = num_row_blocks_e_; r < bs->rows.size(); ++r) {
     const int row_block_pos = bs->rows[r].block.position;
     const int row_block_size = bs->rows[r].block.size;
-    const vector<Cell>& cells = bs->rows[r].cells;
+    const std::vector<Cell>& cells = bs->rows[r].cells;
     for (int c = 0; c < cells.size(); ++c) {
       const int col_block_id = cells[c].block_id;
       const int col_block_pos = bs->cols[col_block_id].position;
@@ -197,7 +197,7 @@
   for (int r = 0; r < num_row_blocks_e_; ++r) {
     const int row_block_pos = bs->rows[r].block.position;
     const int row_block_size = bs->rows[r].block.size;
-    const vector<Cell>& cells = bs->rows[r].cells;
+    const std::vector<Cell>& cells = bs->rows[r].cells;
     for (int c = 1; c < cells.size(); ++c) {
       const int col_block_id = cells[c].block_id;
       const int col_block_pos = bs->cols[col_block_id].position;
@@ -212,7 +212,7 @@
   for (int r = num_row_blocks_e_; r < bs->rows.size(); ++r) {
     const int row_block_pos = bs->rows[r].block.position;
     const int row_block_size = bs->rows[r].block.size;
-    const vector<Cell>& cells = bs->rows[r].cells;
+    const std::vector<Cell>& cells = bs->rows[r].cells;
     for (int c = 0; c < cells.size(); ++c) {
       const int col_block_id = cells[c].block_id;
       const int col_block_pos = bs->cols[col_block_id].position;
@@ -339,7 +339,7 @@
   const double* values = matrix_.values();
   for (int r = 0; r < num_row_blocks_e_; ++r) {
     const int row_block_size = bs->rows[r].block.size;
-    const vector<Cell>& cells = bs->rows[r].cells;
+    const std::vector<Cell>& cells = bs->rows[r].cells;
     for (int c = 1; c < cells.size(); ++c) {
       const int col_block_id = cells[c].block_id;
       const int col_block_size = bs->cols[col_block_id].size;
@@ -358,7 +358,7 @@
 
   for (int r = num_row_blocks_e_; r < bs->rows.size(); ++r) {
     const int row_block_size = bs->rows[r].block.size;
-    const vector<Cell>& cells = bs->rows[r].cells;
+    const std::vector<Cell>& cells = bs->rows[r].cells;
     for (int c = 0; c < cells.size(); ++c) {
       const int col_block_id = cells[c].block_id;
       const int col_block_size = bs->cols[col_block_id].size;
diff --git a/internal/ceres/polynomial.cc b/internal/ceres/polynomial.cc
index 75f43de..848fbee 100644
--- a/internal/ceres/polynomial.cc
+++ b/internal/ceres/polynomial.cc
@@ -42,6 +42,9 @@
 
 namespace ceres {
 namespace internal {
+
+using std::vector;
+
 namespace {
 
 // Balancing function as described by B. N. Parlett and C. Reinsch,
diff --git a/internal/ceres/polynomial.h b/internal/ceres/polynomial.h
index 80ce77e..aaa4401 100644
--- a/internal/ceres/polynomial.h
+++ b/internal/ceres/polynomial.h
@@ -32,6 +32,7 @@
 #ifndef CERES_INTERNAL_POLYNOMIAL_SOLVER_H_
 #define CERES_INTERNAL_POLYNOMIAL_SOLVER_H_
 
+#include <string>
 #include <vector>
 #include "ceres/internal/eigen.h"
 #include "ceres/internal/port.h"
@@ -115,7 +116,7 @@
 // Of course its possible to sample a polynomial any number of times,
 // in which case, generally speaking the spurious higher order
 // coefficients will be zero.
-Vector FindInterpolatingPolynomial(const vector<FunctionSample>& samples);
+Vector FindInterpolatingPolynomial(const std::vector<FunctionSample>& samples);
 
 // Interpolate the function described by samples with a polynomial,
 // and minimize it on the interval [x_min, x_max]. Depending on the
@@ -123,7 +124,7 @@
 // finding algorithms may fail due to numerical difficulties. But the
 // function is guaranteed to return its best guess of an answer, by
 // considering the samples and the end points as possible solutions.
-void MinimizeInterpolatingPolynomial(const vector<FunctionSample>& samples,
+void MinimizeInterpolatingPolynomial(const std::vector<FunctionSample>& samples,
                                      double x_min,
                                      double x_max,
                                      double* optimal_x,
diff --git a/internal/ceres/polynomial_test.cc b/internal/ceres/polynomial_test.cc
index 3339973..de111f6 100644
--- a/internal/ceres/polynomial_test.cc
+++ b/internal/ceres/polynomial_test.cc
@@ -40,6 +40,9 @@
 
 namespace ceres {
 namespace internal {
+
+using std::vector;
+
 namespace {
 
 // For IEEE-754 doubles, machine precision is about 2e-16.
diff --git a/internal/ceres/preconditioner.h b/internal/ceres/preconditioner.h
index e8d5994..5db5356 100644
--- a/internal/ceres/preconditioner.h
+++ b/internal/ceres/preconditioner.h
@@ -80,7 +80,7 @@
     // elimination group must form an independent set in the normal
     // equations. The first elimination group corresponds to the
     // num_eliminate_blocks in the Schur type solvers.
-    vector<int> elimination_groups;
+    std::vector<int> elimination_groups;
 
     // If the block sizes in a BlockSparseMatrix are fixed, then in
     // some cases the Schur complement based solvers can detect and
diff --git a/internal/ceres/preprocessor.h b/internal/ceres/preprocessor.h
index b4ca5b1..5269eeb 100644
--- a/internal/ceres/preprocessor.h
+++ b/internal/ceres/preprocessor.h
@@ -31,6 +31,9 @@
 #ifndef CERES_INTERNAL_PREPROCESSOR_H_
 #define CERES_INTERNAL_PREPROCESSOR_H_
 
+#include <string>
+#include <vector>
+
 #include "ceres/coordinate_descent_minimizer.h"
 #include "ceres/evaluator.h"
 #include "ceres/internal/eigen.h"
@@ -65,7 +68,7 @@
 // The output of the Preprocessor is stored in a PreprocessedProblem
 // object.
 class Preprocessor {
-public:
+ public:
   // Factory.
   static Preprocessor* Create(MinimizerType minimizer_type);
   virtual ~Preprocessor();
@@ -97,7 +100,7 @@
   shared_ptr<Evaluator> evaluator;
   shared_ptr<CoordinateDescentMinimizer> inner_iteration_minimizer;
 
-  vector<double*> removed_parameter_blocks;
+  std::vector<double*> removed_parameter_blocks;
   Vector reduced_parameters;
   double fixed_cost;
 };
diff --git a/internal/ceres/problem.cc b/internal/ceres/problem.cc
index bbfaa98..5f914bc 100644
--- a/internal/ceres/problem.cc
+++ b/internal/ceres/problem.cc
@@ -37,6 +37,8 @@
 
 namespace ceres {
 
+using std::vector;
+
 Problem::Problem() : problem_impl_(new internal::ProblemImpl) {}
 Problem::Problem(const Problem::Options& options)
     : problem_impl_(new internal::ProblemImpl(options)) {}
@@ -225,11 +227,11 @@
 
 int Problem::ParameterBlockSize(const double* parameter_block) const {
   return problem_impl_->ParameterBlockSize(parameter_block);
-};
+}
 
 int Problem::ParameterBlockLocalSize(const double* parameter_block) const {
   return problem_impl_->ParameterBlockLocalSize(parameter_block);
-};
+}
 
 bool Problem::HasParameterBlock(const double* values) const {
   return problem_impl_->HasParameterBlock(values);
diff --git a/internal/ceres/problem_impl.cc b/internal/ceres/problem_impl.cc
index 67cac94..a363248 100644
--- a/internal/ceres/problem_impl.cc
+++ b/internal/ceres/problem_impl.cc
@@ -55,7 +55,10 @@
 namespace ceres {
 namespace internal {
 
-typedef map<double*, internal::ParameterBlock*> ParameterMap;
+using std::vector;
+using std::map;
+
+typedef std::map<double*, internal::ParameterBlock*> ParameterMap;
 
 namespace {
 internal::ParameterBlock* FindParameterBlockOrDie(
@@ -784,12 +787,12 @@
 int ProblemImpl::ParameterBlockSize(const double* parameter_block) const {
   return FindParameterBlockOrDie(parameter_block_map_,
                                  const_cast<double*>(parameter_block))->Size();
-};
+}
 
 int ProblemImpl::ParameterBlockLocalSize(const double* parameter_block) const {
   return FindParameterBlockOrDie(
       parameter_block_map_, const_cast<double*>(parameter_block))->LocalSize();
-};
+}
 
 bool ProblemImpl::HasParameterBlock(const double* parameter_block) const {
   return (parameter_block_map_.find(const_cast<double*>(parameter_block)) !=
diff --git a/internal/ceres/problem_impl.h b/internal/ceres/problem_impl.h
index 3d84de8..f527d15 100644
--- a/internal/ceres/problem_impl.h
+++ b/internal/ceres/problem_impl.h
@@ -63,7 +63,7 @@
 
 class ProblemImpl {
  public:
-  typedef map<double*, ParameterBlock*> ParameterMap;
+  typedef std::map<double*, ParameterBlock*> ParameterMap;
   typedef HashSet<ResidualBlock*> ResidualBlockSet;
 
   ProblemImpl();
@@ -72,9 +72,10 @@
   ~ProblemImpl();
 
   // See the public problem.h file for description of these methods.
-  ResidualBlockId AddResidualBlock(CostFunction* cost_function,
-                                   LossFunction* loss_function,
-                                   const vector<double*>& parameter_blocks);
+  ResidualBlockId AddResidualBlock(
+      CostFunction* cost_function,
+      LossFunction* loss_function,
+      const std::vector<double*>& parameter_blocks);
   ResidualBlockId AddResidualBlock(CostFunction* cost_function,
                                    LossFunction* loss_function,
                                    double* x0);
@@ -136,8 +137,8 @@
 
   bool Evaluate(const Problem::EvaluateOptions& options,
                 double* cost,
-                vector<double>* residuals,
-                vector<double>* gradient,
+                std::vector<double>* residuals,
+                std::vector<double>* gradient,
                 CRSMatrix* jacobian);
 
   int NumParameterBlocks() const;
@@ -150,12 +151,12 @@
 
   bool HasParameterBlock(const double* parameter_block) const;
 
-  void GetParameterBlocks(vector<double*>* parameter_blocks) const;
-  void GetResidualBlocks(vector<ResidualBlockId>* residual_blocks) const;
+  void GetParameterBlocks(std::vector<double*>* parameter_blocks) const;
+  void GetResidualBlocks(std::vector<ResidualBlockId>* residual_blocks) const;
 
   void GetParameterBlocksForResidualBlock(
       const ResidualBlockId residual_block,
-      vector<double*>* parameter_blocks) const;
+      std::vector<double*>* parameter_blocks) const;
 
   const CostFunction* GetCostFunctionForResidualBlock(
       const ResidualBlockId residual_block) const;
@@ -164,7 +165,7 @@
 
   void GetResidualBlocksForParameterBlock(
       const double* values,
-      vector<ResidualBlockId>* residual_blocks) const;
+      std::vector<ResidualBlockId>* residual_blocks) const;
 
   const Program& program() const { return *program_; }
   Program* mutable_program() { return program_.get(); }
@@ -182,15 +183,15 @@
 
   bool InternalEvaluate(Program* program,
                         double* cost,
-                        vector<double>* residuals,
-                        vector<double>* gradient,
+                        std::vector<double>* residuals,
+                        std::vector<double>* gradient,
                         CRSMatrix* jacobian);
 
   // Delete the arguments in question. These differ from the Remove* functions
   // in that they do not clean up references to the block to delete; they
   // merely delete them.
   template<typename Block>
-  void DeleteBlockInVector(vector<Block*>* mutable_blocks,
+  void DeleteBlockInVector(std::vector<Block*>* mutable_blocks,
                            Block* block_to_remove);
   void DeleteBlock(ResidualBlock* residual_block);
   void DeleteBlock(ParameterBlock* parameter_block);
@@ -198,7 +199,7 @@
   const Problem::Options options_;
 
   // The mapping from user pointers to parameter blocks.
-  map<double*, ParameterBlock*> parameter_block_map_;
+  std::map<double*, ParameterBlock*> parameter_block_map_;
 
   // Iff enable_fast_removal is enabled, contains the current residual blocks.
   ResidualBlockSet residual_block_set_;
@@ -212,9 +213,9 @@
   // residual or parameter blocks, buffer them until destruction.
   //
   // TODO(keir): See if it makes sense to use sets instead.
-  vector<CostFunction*> cost_functions_to_delete_;
-  vector<LossFunction*> loss_functions_to_delete_;
-  vector<LocalParameterization*> local_parameterizations_to_delete_;
+  std::vector<CostFunction*> cost_functions_to_delete_;
+  std::vector<LossFunction*> loss_functions_to_delete_;
+  std::vector<LocalParameterization*> local_parameterizations_to_delete_;
 
   CERES_DISALLOW_COPY_AND_ASSIGN(ProblemImpl);
 };
diff --git a/internal/ceres/problem_test.cc b/internal/ceres/problem_test.cc
index 36e4996..7f8c158 100644
--- a/internal/ceres/problem_test.cc
+++ b/internal/ceres/problem_test.cc
@@ -35,7 +35,7 @@
 #include "ceres/casts.h"
 #include "ceres/cost_function.h"
 #include "ceres/crs_matrix.h"
-#include "ceres/evaluator_test_utils.cc"
+#include "ceres/evaluator_test_utils.h"
 #include "ceres/internal/eigen.h"
 #include "ceres/internal/scoped_ptr.h"
 #include "ceres/local_parameterization.h"
@@ -51,6 +51,8 @@
 namespace ceres {
 namespace internal {
 
+using std::vector;
+
 // The following three classes are for the purposes of defining
 // function signatures. They have dummy Evaluate functions.
 
diff --git a/internal/ceres/program.cc b/internal/ceres/program.cc
index 1d0a157..77bc63a 100644
--- a/internal/ceres/program.cc
+++ b/internal/ceres/program.cc
@@ -50,6 +50,9 @@
 namespace ceres {
 namespace internal {
 
+using std::set;
+using std::vector;
+
 Program::Program() {}
 
 Program::Program(const Program& program)
@@ -261,9 +264,10 @@
   return true;
 }
 
-Program* Program::CreateReducedProgram(vector<double*>* removed_parameter_blocks,
-                                       double* fixed_cost,
-                                       string* error) const {
+Program* Program::CreateReducedProgram(
+    vector<double*>* removed_parameter_blocks,
+    double* fixed_cost,
+    string* error) const {
   CHECK_NOTNULL(removed_parameter_blocks);
   CHECK_NOTNULL(fixed_cost);
   CHECK_NOTNULL(error);
@@ -279,9 +283,10 @@
   return reduced_program.release();
 }
 
-bool Program::RemoveFixedBlocks(vector<double*>* removed_parameter_blocks,
-                                double* fixed_cost,
-                                string* error) {
+bool Program::RemoveFixedBlocks(
+    vector<double*>* removed_parameter_blocks,
+    double* fixed_cost,
+    string* error) {
   CHECK_NOTNULL(removed_parameter_blocks);
   CHECK_NOTNULL(fixed_cost);
   CHECK_NOTNULL(error);
@@ -342,7 +347,8 @@
   for (int i = 0; i < parameter_blocks_.size(); ++i) {
     ParameterBlock* parameter_block = parameter_blocks_[i];
     if (parameter_block->index() == -1) {
-      removed_parameter_blocks->push_back(parameter_block->mutable_user_state());
+      removed_parameter_blocks->push_back(
+          parameter_block->mutable_user_state());
     } else {
       parameter_blocks_[num_active_parameter_blocks++] = parameter_block;
     }
@@ -360,14 +366,14 @@
   return true;
 }
 
-bool Program::IsParameterBlockSetIndependent(const set<double*>& independent_set) const {
+bool Program::IsParameterBlockSetIndependent(
+    const set<double*>& independent_set) const {
   // Loop over each residual block and ensure that no two parameter
   // blocks in the same residual block are part of
   // parameter_block_ptrs as that would violate the assumption that it
   // is an independent set in the Hessian matrix.
-  for (vector<ResidualBlock*>::const_iterator it = residual_blocks_.begin();
-       it != residual_blocks_.end();
-       ++it) {
+  vector<ResidualBlock*>::const_iterator it = residual_blocks_.begin();
+  for (; it != residual_blocks_.end(); ++it) {
     ParameterBlock* const* parameter_blocks = (*it)->parameter_blocks();
     const int num_parameter_blocks = (*it)->NumParameterBlocks();
     int count = 0;
@@ -462,8 +468,8 @@
   int max_scratch_bytes_for_evaluate = 0;
   for (int i = 0; i < residual_blocks_.size(); ++i) {
     max_scratch_bytes_for_evaluate =
-        max(max_scratch_bytes_for_evaluate,
-            residual_blocks_[i]->NumScratchDoublesForEvaluate());
+        std::max(max_scratch_bytes_for_evaluate,
+                 residual_blocks_[i]->NumScratchDoublesForEvaluate());
   }
   return max_scratch_bytes_for_evaluate;
 }
@@ -478,7 +484,7 @@
       derivatives += residual_block->NumResiduals() *
                      residual_block->parameter_blocks()[j]->LocalSize();
     }
-    max_derivatives = max(max_derivatives, derivatives);
+    max_derivatives = std::max(max_derivatives, derivatives);
   }
   return max_derivatives;
 }
@@ -486,8 +492,8 @@
 int Program::MaxParametersPerResidualBlock() const {
   int max_parameters = 0;
   for (int i = 0; i < residual_blocks_.size(); ++i) {
-    max_parameters = max(max_parameters,
-                         residual_blocks_[i]->NumParameterBlocks());
+    max_parameters = std::max(max_parameters,
+                              residual_blocks_[i]->NumParameterBlocks());
   }
   return max_parameters;
 }
@@ -495,8 +501,8 @@
 int Program::MaxResidualsPerResidualBlock() const {
   int max_residuals = 0;
   for (int i = 0; i < residual_blocks_.size(); ++i) {
-    max_residuals = max(max_residuals,
-                        residual_blocks_[i]->NumResiduals());
+    max_residuals = std::max(max_residuals,
+                             residual_blocks_[i]->NumResiduals());
   }
   return max_residuals;
 }
diff --git a/internal/ceres/program.h b/internal/ceres/program.h
index c7b22c4..54dc271 100644
--- a/internal/ceres/program.h
+++ b/internal/ceres/program.h
@@ -60,10 +60,10 @@
   explicit Program(const Program& program);
 
   // The ordered parameter and residual blocks for the program.
-  const vector<ParameterBlock*>& parameter_blocks() const;
-  const vector<ResidualBlock*>& residual_blocks() const;
-  vector<ParameterBlock*>* mutable_parameter_blocks();
-  vector<ResidualBlock*>* mutable_residual_blocks();
+  const std::vector<ParameterBlock*>& parameter_blocks() const;
+  const std::vector<ResidualBlock*>& residual_blocks() const;
+  std::vector<ParameterBlock*>* mutable_parameter_blocks();
+  std::vector<ResidualBlock*>* mutable_residual_blocks();
 
   // Serialize to/from the program and update states.
   //
@@ -120,7 +120,8 @@
   // blocks in the same residual block are part of
   // parameter_blocks as that would violate the assumption that it
   // is an independent set in the Hessian matrix.
-  bool IsParameterBlockSetIndependent(const set<double*>& independent_set) const;
+  bool IsParameterBlockSetIndependent(
+      const std::set<double*>& independent_set) const;
 
   // Create a TripletSparseMatrix which contains the zero-one
   // structure corresponding to the block sparsity of the transpose of
@@ -142,7 +143,7 @@
   // If there was a problem, then the function will return a NULL
   // pointer and error will contain a human readable description of
   // the problem.
-  Program* CreateReducedProgram(vector<double*>* removed_parameter_blocks,
+  Program* CreateReducedProgram(std::vector<double*>* removed_parameter_blocks,
                                 double* fixed_cost,
                                 string* error) const;
 
@@ -174,13 +175,13 @@
   //
   // If there was a problem, then the function will return false and
   // error will contain a human readable description of the problem.
-  bool RemoveFixedBlocks(vector<double*>* removed_parameter_blocks,
+  bool RemoveFixedBlocks(std::vector<double*>* removed_parameter_blocks,
                          double* fixed_cost,
                          string* message);
 
   // The Program does not own the ParameterBlock or ResidualBlock objects.
-  vector<ParameterBlock*> parameter_blocks_;
-  vector<ResidualBlock*> residual_blocks_;
+  std::vector<ParameterBlock*> parameter_blocks_;
+  std::vector<ResidualBlock*> residual_blocks_;
 
   friend class ProblemImpl;
 };
diff --git a/internal/ceres/program_evaluator.h b/internal/ceres/program_evaluator.h
index 672c233..24ed3ae 100644
--- a/internal/ceres/program_evaluator.h
+++ b/internal/ceres/program_evaluator.h
@@ -297,11 +297,11 @@
     return program_->NumResiduals();
   }
 
-  virtual map<string, int> CallStatistics() const {
+  virtual std::map<string, int> CallStatistics() const {
     return execution_summary_.calls();
   }
 
-  virtual map<string, double> TimeStatistics() const {
+  virtual std::map<string, double> TimeStatistics() const {
     return execution_summary_.times();
   }
 
@@ -332,8 +332,9 @@
   };
 
   static void BuildResidualLayout(const Program& program,
-                                  vector<int>* residual_layout) {
-    const vector<ResidualBlock*>& residual_blocks = program.residual_blocks();
+                                  std::vector<int>* residual_layout) {
+    const std::vector<ResidualBlock*>& residual_blocks =
+        program.residual_blocks();
     residual_layout->resize(program.NumResidualBlocks());
     int residual_pos = 0;
     for (int i = 0; i < residual_blocks.size(); ++i) {
@@ -369,7 +370,7 @@
   JacobianWriter jacobian_writer_;
   scoped_array<EvaluatePreparer> evaluate_preparers_;
   scoped_array<EvaluateScratch> evaluate_scratch_;
-  vector<int> residual_layout_;
+  std::vector<int> residual_layout_;
   ::ceres::internal::ExecutionSummary execution_summary_;
 };
 
diff --git a/internal/ceres/program_test.cc b/internal/ceres/program_test.cc
index 10bfa12..77a1c44 100644
--- a/internal/ceres/program_test.cc
+++ b/internal/ceres/program_test.cc
@@ -42,6 +42,8 @@
 namespace ceres {
 namespace internal {
 
+using std::vector;
+
 // A cost function that simply returns its argument.
 class UnaryIdentityCostFunction : public SizedCostFunction<1, 1> {
  public:
@@ -222,7 +224,8 @@
   problem.AddResidualBlock(new BinaryCostFunction(), NULL, &x, &y);
   problem.SetParameterBlockConstant(&x);
 
-  ResidualBlock *expected_removed_block = problem.program().residual_blocks()[0];
+  ResidualBlock *expected_removed_block =
+      problem.program().residual_blocks()[0];
   scoped_array<double> scratch(
       new double[expected_removed_block->NumScratchDoublesForEvaluate()]);
   double expected_fixed_cost;
@@ -307,7 +310,7 @@
 
     rows[13] = 1;
     cols[13] = 7;
-    fill(values, values + 14, 1.0);
+    std::fill(values, values + 14, 1.0);
     expected_block_sparse_jacobian.set_num_nonzeros(14);
   }
 
@@ -374,7 +377,7 @@
     }
 
     double* values = expected_block_sparse_jacobian.mutable_values();
-    fill(values, values + 20, 1.0);
+    std::fill(values, values + 20, 1.0);
     expected_block_sparse_jacobian.set_num_nonzeros(20);
   }
 
diff --git a/internal/ceres/reorder_program.cc b/internal/ceres/reorder_program.cc
index aa3d4ce..fad69f9 100644
--- a/internal/ceres/reorder_program.cc
+++ b/internal/ceres/reorder_program.cc
@@ -56,6 +56,11 @@
 
 namespace ceres {
 namespace internal {
+
+using std::map;
+using std::set;
+using std::vector;
+
 namespace {
 
 // Find the minimum index of any parameter block to the given
@@ -87,7 +92,7 @@
   const int* rows = block_jacobian_transpose.rows();
   const int* cols = block_jacobian_transpose.cols();
   int num_nonzeros = block_jacobian_transpose.num_nonzeros();
-  std::vector<Triplet> triplets;
+  vector<Triplet> triplets;
   triplets.reserve(num_nonzeros);
   for (int i = 0; i < num_nonzeros; ++i) {
     triplets.push_back(Triplet(cols[i], rows[i], 1));
@@ -220,13 +225,11 @@
   const map<int, set<double*> >& groups =
       ordering.group_to_elements();
 
-  for (map<int, set<double*> >::const_iterator group_it = groups.begin();
-       group_it != groups.end();
-       ++group_it) {
+  map<int, set<double*> >::const_iterator group_it = groups.begin();
+  for ( ; group_it != groups.end(); ++group_it) {
     const set<double*>& group = group_it->second;
-    for (set<double*>::const_iterator parameter_block_ptr_it = group.begin();
-         parameter_block_ptr_it != group.end();
-         ++parameter_block_ptr_it) {
+    set<double*>::const_iterator parameter_block_ptr_it = group.begin();
+    for ( ; parameter_block_ptr_it != group.end(); ++parameter_block_ptr_it) {
       ProblemImpl::ParameterMap::const_iterator parameter_block_it =
           parameter_map.find(*parameter_block_ptr_it);
       if (parameter_block_it == parameter_map.end()) {
@@ -252,8 +255,10 @@
 
   // Create a histogram of the number of residuals for each E block. There is an
   // extra bucket at the end to catch all non-eliminated F blocks.
-  vector<int> residual_blocks_per_e_block(size_of_first_elimination_group + 1);
-  vector<ResidualBlock*>* residual_blocks = program->mutable_residual_blocks();
+  vector<int> residual_blocks_per_e_block(
+      size_of_first_elimination_group + 1);
+  vector<ResidualBlock*>* residual_blocks =
+      program->mutable_residual_blocks();
   vector<int> min_position_per_residual(residual_blocks->size());
   for (int i = 0; i < residual_blocks->size(); ++i) {
     ResidualBlock* residual_block = (*residual_blocks)[i];
@@ -409,7 +414,8 @@
   Eigen::PermutationMatrix<Eigen::Dynamic, Eigen::Dynamic, int> perm;
   amd_ordering(block_schur_complement, perm);
 
-  const vector<ParameterBlock*>& parameter_blocks = program->parameter_blocks();
+  const vector<ParameterBlock*>& parameter_blocks =
+      program->parameter_blocks();
   vector<ParameterBlock*> ordering(num_cols);
 
   // The ordering of the first size_of_first_elimination_group does
diff --git a/internal/ceres/reorder_program_test.cc b/internal/ceres/reorder_program_test.cc
index 2a0c4eb..6f2b1b0 100644
--- a/internal/ceres/reorder_program_test.cc
+++ b/internal/ceres/reorder_program_test.cc
@@ -41,6 +41,8 @@
 namespace ceres {
 namespace internal {
 
+using std::vector;
+
 // Templated base class for the CostFunction signatures.
 template <int kNumResiduals, int N0, int N1, int N2>
 class MockCostFunctionBase : public
@@ -158,7 +160,8 @@
                             linear_solver_ordering,
                             program,
                             &message));
-  const vector<ParameterBlock*>& parameter_blocks = program->parameter_blocks();
+  const vector<ParameterBlock*>& parameter_blocks =
+      program->parameter_blocks();
 
   EXPECT_EQ(parameter_blocks.size(), 3);
   EXPECT_EQ(parameter_blocks[0]->user_state(), &x);
diff --git a/internal/ceres/residual_block.cc b/internal/ceres/residual_block.cc
index 621082a..5eb2117 100644
--- a/internal/ceres/residual_block.cc
+++ b/internal/ceres/residual_block.cc
@@ -49,10 +49,11 @@
 namespace ceres {
 namespace internal {
 
-ResidualBlock::ResidualBlock(const CostFunction* cost_function,
-                             const LossFunction* loss_function,
-                             const vector<ParameterBlock*>& parameter_blocks,
-                             int index)
+ResidualBlock::ResidualBlock(
+    const CostFunction* cost_function,
+    const LossFunction* loss_function,
+    const std::vector<ParameterBlock*>& parameter_blocks,
+    int index)
     : cost_function_(cost_function),
       loss_function_(loss_function),
       parameter_blocks_(
diff --git a/internal/ceres/residual_block.h b/internal/ceres/residual_block.h
index 9c3671b..b936064 100644
--- a/internal/ceres/residual_block.h
+++ b/internal/ceres/residual_block.h
@@ -71,7 +71,7 @@
   // residual_blocks array.
   ResidualBlock(const CostFunction* cost_function,
                 const LossFunction* loss_function,
-                const vector<ParameterBlock*>& parameter_blocks,
+                const std::vector<ParameterBlock*>& parameter_blocks,
                 int index);
 
   // Evaluates the residual term, storing the scalar cost in *cost, the residual
diff --git a/internal/ceres/residual_block_test.cc b/internal/ceres/residual_block_test.cc
index b37f50f..22873e7 100644
--- a/internal/ceres/residual_block_test.cc
+++ b/internal/ceres/residual_block_test.cc
@@ -39,6 +39,8 @@
 namespace ceres {
 namespace internal {
 
+using std::vector;
+
 // Trivial cost function that accepts three arguments.
 class TernaryCostFunction: public CostFunction {
  public:
diff --git a/internal/ceres/residual_block_utils_test.cc b/internal/ceres/residual_block_utils_test.cc
index d3c917a..64bf0db 100644
--- a/internal/ceres/residual_block_utils_test.cc
+++ b/internal/ceres/residual_block_utils_test.cc
@@ -46,7 +46,7 @@
 void CheckEvaluation(const CostFunction& cost_function, bool is_good) {
   double x = 1.0;
   ParameterBlock parameter_block(&x, 1, -1);
-  vector<ParameterBlock*> parameter_blocks;
+  std::vector<ParameterBlock*> parameter_blocks;
   parameter_blocks.push_back(&parameter_block);
 
   ResidualBlock residual_block(&cost_function,
diff --git a/internal/ceres/rotation_test.cc b/internal/ceres/rotation_test.cc
index 2764e66..ef1adf7 100644
--- a/internal/ceres/rotation_test.cc
+++ b/internal/ceres/rotation_test.cc
@@ -44,6 +44,8 @@
 namespace ceres {
 namespace internal {
 
+using std::swap;
+
 const double kPi = 3.14159265358979323846;
 const double kHalfSqrt2 = 0.707106781186547524401;
 
@@ -53,7 +55,7 @@
 }
 
 // A tolerance value for floating-point comparisons.
-static double const kTolerance = numeric_limits<double>::epsilon() * 10;
+static double const kTolerance = std::numeric_limits<double>::epsilon() * 10;
 
 // Looser tolerance used for numerically unstable conversions.
 static double const kLooseTolerance = 1e-9;
@@ -241,7 +243,7 @@
 // Test that approximate conversion works for very small angles.
 TEST(Rotation, TinyAngleAxisToQuaternion) {
   // Very small value that could potentially cause underflow.
-  double theta = pow(numeric_limits<double>::min(), 0.75);
+  double theta = pow(std::numeric_limits<double>::min(), 0.75);
   double axis_angle[3] = { theta, 0, 0 };
   double quaternion[4];
   double expected[4] = { cos(theta/2), sin(theta/2.0), 0, 0 };
@@ -302,7 +304,7 @@
 // Test that approximate conversion works for very small angles.
 TEST(Rotation, TinyQuaternionToAngleAxis) {
   // Very small value that could potentially cause underflow.
-  double theta = pow(numeric_limits<double>::min(), 0.75);
+  double theta = pow(std::numeric_limits<double>::min(), 0.75);
   double quaternion[4] = { cos(theta/2), sin(theta/2.0), 0, 0 };
   double axis_angle[3];
   double expected[3] = { theta, 0, 0 };
@@ -604,9 +606,9 @@
 
 // Transposes a 3x3 matrix.
 static void Transpose3x3(double m[9]) {
-  std::swap(m[1], m[3]);
-  std::swap(m[2], m[6]);
-  std::swap(m[5], m[7]);
+  swap(m[1], m[3]);
+  swap(m[2], m[6]);
+  swap(m[5], m[7]);
 }
 
 // Convert Euler angles from radians to degrees.
@@ -699,7 +701,7 @@
   if (x == 0 || y == 0) {
     return absdiff <= kTolerance;
   }
-  double reldiff = absdiff / max(fabs(x), fabs(y));
+  double reldiff = absdiff / std::max(fabs(x), fabs(y));
   return reldiff <= kTolerance;
 }
 
@@ -735,11 +737,11 @@
 
 // Log-10 of a value well below machine precision.
 static const int kSmallTinyCutoff =
-    static_cast<int>(2 * log(numeric_limits<double>::epsilon())/log(10.0));
+    static_cast<int>(2 * log(std::numeric_limits<double>::epsilon())/log(10.0));
 
 // Log-10 of a value just below values representable by double.
 static const int kTinyZeroLimit   =
-    static_cast<int>(1 + log(numeric_limits<double>::min())/log(10.0));
+    static_cast<int>(1 + log(std::numeric_limits<double>::min())/log(10.0));
 
 // Test that exact conversion works for small angles when jets are used.
 TEST(Rotation, SmallAngleAxisToQuaternionForJets) {
diff --git a/internal/ceres/schur_complement_solver.cc b/internal/ceres/schur_complement_solver.cc
index 33f812b..0c72eb3 100644
--- a/internal/ceres/schur_complement_solver.cc
+++ b/internal/ceres/schur_complement_solver.cc
@@ -57,10 +57,16 @@
 
 namespace ceres {
 namespace internal {
+
+using std::make_pair;
+using std::pair;
+using std::set;
+using std::vector;
+
 namespace {
 
 class BlockRandomAccessSparseMatrixAdapter : public LinearOperator {
-  public:
+ public:
   explicit BlockRandomAccessSparseMatrixAdapter(
       const BlockRandomAccessSparseMatrix& m)
       : m_(m) {
@@ -86,7 +92,7 @@
 };
 
 class BlockRandomAccessDiagonalMatrixAdapter : public LinearOperator {
-  public:
+ public:
   explicit BlockRandomAccessDiagonalMatrixAdapter(
       const BlockRandomAccessDiagonalMatrix& m)
       : m_(m) {
@@ -130,7 +136,7 @@
     eliminator_.reset(CHECK_NOTNULL(SchurEliminatorBase::Create(options_)));
     eliminator_->Init(options_.elimination_groups[0], A->block_structure());
   };
-  fill(x, x + A->num_cols(), 0.0);
+  std::fill(x, x + A->num_cols(), 0.0);
   event_logger.AddEvent("Setup");
 
   eliminator_->Eliminate(A, b, per_solve_options.D, lhs_.get(), rhs_.get());
diff --git a/internal/ceres/schur_complement_solver.h b/internal/ceres/schur_complement_solver.h
index 93d23e3..59d900f 100644
--- a/internal/ceres/schur_complement_solver.h
+++ b/internal/ceres/schur_complement_solver.h
@@ -188,7 +188,7 @@
       double* solution);
 
   // Size of the blocks in the Schur complement.
-  vector<int> blocks_;
+  std::vector<int> blocks_;
 
   SuiteSparse ss_;
   // Symbolic factorization of the reduced linear system. Precomputed
diff --git a/internal/ceres/schur_eliminator.h b/internal/ceres/schur_eliminator.h
index 8fe8b9c..abe2a60 100644
--- a/internal/ceres/schur_eliminator.h
+++ b/internal/ceres/schur_eliminator.h
@@ -263,7 +263,7 @@
   // buffer_layout[z1] = 0
   // buffer_layout[z5] = y1 * z1
   // buffer_layout[z2] = y1 * z1 + y1 * z5
-  typedef map<int, int> BufferLayoutType;
+  typedef std::map<int, int> BufferLayoutType;
   struct Chunk {
     Chunk() : size(0) {}
     int size;
@@ -315,11 +315,11 @@
   // position of each f block in the row/col of the reduced linear
   // system. Thus lhs_row_layout_[i] is the row/col position of the
   // i^th f block.
-  vector<int> lhs_row_layout_;
+  std::vector<int> lhs_row_layout_;
 
   // Combinatorial structure of the chunks in A. For more information
   // see the documentation of the Chunk object above.
-  vector<Chunk> chunks_;
+  std::vector<Chunk> chunks_;
 
   // TODO(sameeragarwal): The following two arrays contain per-thread
   // storage. They should be refactored into a per thread struct.
@@ -346,7 +346,7 @@
 
   // Locks for the blocks in the right hand side of the reduced linear
   // system.
-  vector<Mutex*> rhs_locks_;
+  std::vector<Mutex*> rhs_locks_;
 };
 
 }  // namespace internal
diff --git a/internal/ceres/schur_eliminator_impl.h b/internal/ceres/schur_eliminator_impl.h
index 305d94e..3318061 100644
--- a/internal/ceres/schur_eliminator_impl.h
+++ b/internal/ceres/schur_eliminator_impl.h
@@ -139,7 +139,7 @@
         }
       }
 
-      buffer_size_ = max(buffer_size, buffer_size_);
+      buffer_size_ = std::max(buffer_size, buffer_size_);
       ++chunk.size;
     }
 
diff --git a/internal/ceres/schur_eliminator_test.cc b/internal/ceres/schur_eliminator_test.cc
index bed8f3a..f36ec0f 100644
--- a/internal/ceres/schur_eliminator_test.cc
+++ b/internal/ceres/schur_eliminator_test.cc
@@ -129,7 +129,7 @@
                                 const double relative_tolerance) {
     const CompressedRowBlockStructure* bs = A->block_structure();
     const int num_col_blocks = bs->cols.size();
-    vector<int> blocks(num_col_blocks - num_eliminate_blocks, 0);
+    std::vector<int> blocks(num_col_blocks - num_eliminate_blocks, 0);
     for (int i = num_eliminate_blocks; i < num_col_blocks; ++i) {
       blocks[i - num_eliminate_blocks] = bs->cols[i].size;
     }
diff --git a/internal/ceres/schur_jacobi_preconditioner.cc b/internal/ceres/schur_jacobi_preconditioner.cc
index cbdb708..2b5ef56 100644
--- a/internal/ceres/schur_jacobi_preconditioner.cc
+++ b/internal/ceres/schur_jacobi_preconditioner.cc
@@ -54,7 +54,7 @@
       << "Jacobian should have atleast 1 f_block for "
       << "SCHUR_JACOBI preconditioner.";
 
-  vector<int> blocks(num_blocks);
+  std::vector<int> blocks(num_blocks);
   for (int i = 0; i < num_blocks; ++i) {
     blocks[i] = bs.cols[i + options_.elimination_groups[0]].size;
   }
diff --git a/internal/ceres/single_linkage_clustering_test.cc b/internal/ceres/single_linkage_clustering_test.cc
index 95692ea..cd31f5e 100644
--- a/internal/ceres/single_linkage_clustering_test.cc
+++ b/internal/ceres/single_linkage_clustering_test.cc
@@ -109,7 +109,7 @@
   //  0-1-2-3 4-5
   graph.AddEdge(0, 1, 1.0);
   graph.AddEdge(1, 2, 1.0);
-  graph.AddEdge(2, 3, 0.5); // Weak link
+  graph.AddEdge(2, 3, 0.5);  // Weak link
   graph.AddEdge(0, 3, 1.0);
 
   // This component should break up into two.
diff --git a/internal/ceres/solver.cc b/internal/ceres/solver.cc
index 738828b..b60efd9 100644
--- a/internal/ceres/solver.cc
+++ b/internal/ceres/solver.cc
@@ -49,6 +49,9 @@
 namespace ceres {
 namespace {
 
+using std::vector;
+using std::map;
+
 #define OPTION_OP(x, y, OP)                                             \
   if (!(options.x OP y)) {                                              \
     std::stringstream ss;                                               \
@@ -625,7 +628,7 @@
                       initial_cost,
                       final_cost,
                       TerminationTypeToString(termination_type));
-};
+}
 
 string Solver::Summary::FullReport() const {
   using internal::VersionString;
@@ -844,7 +847,7 @@
   StringAppendF(&report, "Termination:        %25s (%s)\n",
                 TerminationTypeToString(termination_type), message.c_str());
   return report;
-};
+}
 
 bool Solver::Summary::IsSolutionUsable() const {
   return internal::IsSolutionUsable(*this);
diff --git a/internal/ceres/solver_test.cc b/internal/ceres/solver_test.cc
index 4069578..e4abdef 100644
--- a/internal/ceres/solver_test.cc
+++ b/internal/ceres/solver_test.cc
@@ -79,7 +79,7 @@
   }
   int calls;
   double *x;
-  vector<double> x_values;
+  std::vector<double> x_values;
 };
 
 TEST(Solver, UpdateStateEveryIterationOption) {
diff --git a/internal/ceres/solver_utils.cc b/internal/ceres/solver_utils.cc
index bd304e7..86440eb 100644
--- a/internal/ceres/solver_utils.cc
+++ b/internal/ceres/solver_utils.cc
@@ -31,6 +31,7 @@
 #include <string>
 
 #include "ceres/internal/port.h"
+#include "ceres/solver_utils.h"
 #include "ceres/version.h"
 
 namespace ceres {
diff --git a/internal/ceres/solver_utils.h b/internal/ceres/solver_utils.h
index 41c8a6e..2d1edf8 100644
--- a/internal/ceres/solver_utils.h
+++ b/internal/ceres/solver_utils.h
@@ -31,6 +31,9 @@
 #include <algorithm>
 #include <string>
 
+#include "ceres/iteration_callback.h"
+#include "ceres/types.h"
+
 namespace ceres {
 namespace internal {
 
@@ -48,7 +51,7 @@
   // iteration because the minimizer maybe making non-monotonic steps.
   for (int i = 0; i < summary->iterations.size(); ++i) {
     const IterationSummary& iteration_summary = summary->iterations[i];
-    summary->final_cost = min(iteration_summary.cost, summary->final_cost);
+    summary->final_cost = std::min(iteration_summary.cost, summary->final_cost);
   }
 }
 
diff --git a/internal/ceres/sparse_normal_cholesky_solver.h b/internal/ceres/sparse_normal_cholesky_solver.h
index 12c0524..73edf48 100644
--- a/internal/ceres/sparse_normal_cholesky_solver.h
+++ b/internal/ceres/sparse_normal_cholesky_solver.h
@@ -120,7 +120,7 @@
 #endif
 
   scoped_ptr<CompressedRowSparseMatrix> outer_product_;
-  vector<int> pattern_;
+  std::vector<int> pattern_;
   const LinearSolver::Options options_;
   CERES_DISALLOW_COPY_AND_ASSIGN(SparseNormalCholeskySolver);
 };
diff --git a/internal/ceres/split.cc b/internal/ceres/split.cc
index 3edbc28..0afe1c5 100644
--- a/internal/ceres/split.cc
+++ b/internal/ceres/split.cc
@@ -30,12 +30,16 @@
 
 #include "ceres/split.h"
 
+#include <iterator>
 #include <string>
 #include <vector>
-#include <iterator>
+
 #include "ceres/internal/port.h"
 
 namespace ceres {
+namespace internal {
+
+using std::vector;
 
 // If we know how much to allocate for a vector of strings, we can allocate the
 // vector<string> only once and directly to the right size. This saves in
@@ -110,8 +114,9 @@
                       const char* delim,
                       vector<string>* result) {
   result->reserve(result->size() + CalculateReserveForVector(full, delim));
-  back_insert_iterator< vector<string> > it(*result);
+  std::back_insert_iterator<vector<string> > it(*result);
   SplitStringToIteratorUsing(full, delim, it);
 }
 
+}  // namespace internal
 }  // namespace ceres
diff --git a/internal/ceres/split.h b/internal/ceres/split.h
index 2334d26..ada6676 100644
--- a/internal/ceres/split.h
+++ b/internal/ceres/split.h
@@ -36,13 +36,15 @@
 #include "ceres/internal/port.h"
 
 namespace ceres {
+namespace internal {
 
 // Split a string using one or more character delimiters, presented as a
 // nul-terminated c string. Append the components to 'result'. If there are
 // consecutive delimiters, this function skips over all of them.
 void SplitStringUsing(const string& full, const char* delim,
-                      vector<string>* res);
+                      std::vector<string>* res);
 
+}  // namespace internal
 }  // namespace ceres
 
 #endif  // CERES_INTERNAL_SPLIT_H_
diff --git a/internal/ceres/suitesparse.cc b/internal/ceres/suitesparse.cc
index 1df7566..d8b1a49 100644
--- a/internal/ceres/suitesparse.cc
+++ b/internal/ceres/suitesparse.cc
@@ -44,6 +44,8 @@
 namespace ceres {
 namespace internal {
 
+using std::vector;
+
 SuiteSparse::SuiteSparse() {
   cholmod_start(&cc_);
 }
diff --git a/internal/ceres/suitesparse.h b/internal/ceres/suitesparse.h
index baab899..5aa9cb9 100644
--- a/internal/ceres/suitesparse.h
+++ b/internal/ceres/suitesparse.h
@@ -42,7 +42,6 @@
 #include <string>
 #include <vector>
 
-#include "ceres/internal/port.h"
 #include "ceres/linear_solver.h"
 #include "cholmod.h"
 #include "glog/logging.h"
@@ -147,8 +146,8 @@
   cholmod_factor* AnalyzeCholesky(cholmod_sparse* A, string* message);
 
   cholmod_factor* BlockAnalyzeCholesky(cholmod_sparse* A,
-                                       const vector<int>& row_blocks,
-                                       const vector<int>& col_blocks,
+                                       const std::vector<int>& row_blocks,
+                                       const std::vector<int>& col_blocks,
                                        string* message);
 
   // If A is symmetric, then compute the symbolic Cholesky
@@ -162,9 +161,10 @@
   // message contains an explanation of the failures if any.
   //
   // Caller owns the result.
-  cholmod_factor* AnalyzeCholeskyWithUserOrdering(cholmod_sparse* A,
-                                                  const vector<int>& ordering,
-                                                  string* message);
+  cholmod_factor* AnalyzeCholeskyWithUserOrdering(
+      cholmod_sparse* A,
+      const std::vector<int>& ordering,
+      string* message);
 
   // Perform a symbolic factorization of A without re-ordering A. No
   // postordering of the elimination tree is performed. This ensures
@@ -215,9 +215,9 @@
   // A. If this is the case, only the first sum(col_blocks) are used
   // to compute the ordering.
   bool BlockAMDOrdering(const cholmod_sparse* A,
-                        const vector<int>& row_blocks,
-                        const vector<int>& col_blocks,
-                        vector<int>* ordering);
+                        const std::vector<int>& row_blocks,
+                        const std::vector<int>& col_blocks,
+                        std::vector<int>* ordering);
 
   // Find a fill reducing approximate minimum degree
   // ordering. ordering is expected to be large enough to hold the
@@ -236,7 +236,7 @@
   // being conservative and choosing the next minor version where
   // things are stable.
   static bool IsConstrainedApproximateMinimumDegreeOrderingAvailable() {
-    return (SUITESPARSE_VERSION>4001);
+    return (SUITESPARSE_VERSION > 4001);
   }
 
   // Find a fill reducing approximate minimum degree
@@ -298,7 +298,7 @@
     return false;
   }
 
-  void Free(void*) {};
+  void Free(void* arg) {}
 };
 
 #endif  // CERES_NO_SUITESPARSE
diff --git a/internal/ceres/system_test.cc b/internal/ceres/system_test.cc
index be56f20..54fd30a 100644
--- a/internal/ceres/system_test.cc
+++ b/internal/ceres/system_test.cc
@@ -60,6 +60,8 @@
 namespace ceres {
 namespace internal {
 
+using std::vector;
+
 const bool kAutomaticOrdering = true;
 const bool kUserOrdering = false;
 
@@ -122,8 +124,9 @@
 //       Solver::Options* mutable_solver_options();
 //   };
 template <typename SystemTestProblem>
-void RunSolversAndCheckTheyMatch(const vector<SolverConfig>& configurations,
-                                 const double max_abs_difference) {
+void RunSolversAndCheckTheyMatch(
+    const vector<SolverConfig>& configurations,
+    const double max_abs_difference) {
   int num_configurations = configurations.size();
   vector<SystemTestProblem*> problems;
   vector<vector<double> > final_residuals(num_configurations);
@@ -348,7 +351,7 @@
 
     if (!fptr) {
       LOG(FATAL) << "File Error: unable to open file " << filename;
-    };
+    }
 
     // This will die horribly on invalid files. Them's the breaks.
     FscanfOrDie(fptr, "%d", &num_cameras_);
diff --git a/internal/ceres/test_util.cc b/internal/ceres/test_util.cc
index 8af48ab..9d252e9 100644
--- a/internal/ceres/test_util.cc
+++ b/internal/ceres/test_util.cc
@@ -30,6 +30,8 @@
 //
 // Utility functions useful for testing.
 
+#include "ceres/test_util.h"
+
 #include <algorithm>
 #include <cmath>
 #include "ceres/file.h"
diff --git a/internal/ceres/triplet_sparse_matrix.cc b/internal/ceres/triplet_sparse_matrix.cc
index 824b123..6fdd69c 100644
--- a/internal/ceres/triplet_sparse_matrix.cc
+++ b/internal/ceres/triplet_sparse_matrix.cc
@@ -128,7 +128,7 @@
 }
 
 void TripletSparseMatrix::SetZero() {
-  fill(values_.get(), values_.get() + max_num_nonzeros_, 0.0);
+  std::fill(values_.get(), values_.get() + max_num_nonzeros_, 0.0);
   num_nonzeros_ = 0;
 }
 
@@ -136,7 +136,7 @@
   CHECK_GE(num_nonzeros, 0);
   CHECK_LE(num_nonzeros, max_num_nonzeros_);
   num_nonzeros_ = num_nonzeros;
-};
+}
 
 void TripletSparseMatrix::AllocateMemory() {
   rows_.reset(new int[max_num_nonzeros_]);
diff --git a/internal/ceres/trust_region_minimizer.cc b/internal/ceres/trust_region_minimizer.cc
index 605284d..0a6ce80 100644
--- a/internal/ceres/trust_region_minimizer.cc
+++ b/internal/ceres/trust_region_minimizer.cc
@@ -31,8 +31,8 @@
 #include "ceres/trust_region_minimizer.h"
 
 #include <algorithm>
-#include <cstdlib>
 #include <cmath>
+#include <cstdlib>
 #include <cstring>
 #include <limits>
 #include <string>
@@ -417,7 +417,7 @@
           LOG_IF(WARNING, is_not_silent)
               << "Step failed to evaluate. "
               << "Treating it as a step with infinite cost";
-          new_cost = numeric_limits<double>::max();
+          new_cost = std::numeric_limits<double>::max();
         }
       } else {
         LOG_IF(WARNING, is_not_silent)
@@ -521,7 +521,7 @@
       // reference iteration, allowing for non-monotonic steps.
       iteration_summary.relative_decrease =
           options.use_nonmonotonic_steps
-          ? max(relative_decrease, historical_relative_decrease)
+          ? std::max(relative_decrease, historical_relative_decrease)
           : relative_decrease;
 
       // Normally, the quality of a trust region step is measured by
diff --git a/internal/ceres/trust_region_minimizer_test.cc b/internal/ceres/trust_region_minimizer_test.cc
index 4cad989..0cc2af8 100644
--- a/internal/ceres/trust_region_minimizer_test.cc
+++ b/internal/ceres/trust_region_minimizer_test.cc
@@ -252,7 +252,7 @@
   EXPECT_NEAR(0.0, parameters[1], 0.001);
   EXPECT_NEAR(0.0, parameters[2], 0.001);
   EXPECT_NEAR(0.0, parameters[3], 0.001);
-};
+}
 
 TEST(TrustRegionMinimizer, PowellsSingularFunctionUsingLevenbergMarquardt) {
   // This case is excluded because this has a local minimum and does
@@ -373,7 +373,7 @@
 
 TEST(TrustRegionMinimizer, JacobiScalingTest) {
   int N = 6;
-  std::vector< double* > y(N);
+  std::vector<double*> y(N);
   const double pi = 3.1415926535897932384626433;
   for (int i = 0; i < N; i++) {
     double theta = i * 2. * pi/ static_cast< double >(N);
diff --git a/internal/ceres/trust_region_preprocessor.cc b/internal/ceres/trust_region_preprocessor.cc
index 22ea1ec..129442c 100644
--- a/internal/ceres/trust_region_preprocessor.cc
+++ b/internal/ceres/trust_region_preprocessor.cc
@@ -48,12 +48,16 @@
 
 namespace ceres {
 namespace internal {
+
+using std::vector;
+
 namespace {
 
 ParameterBlockOrdering* CreateDefaultLinearSolverOrdering(
     const Program& program) {
   ParameterBlockOrdering* ordering = new ParameterBlockOrdering;
-  const vector<ParameterBlock*>& parameter_blocks = program.parameter_blocks();
+  const vector<ParameterBlock*>& parameter_blocks =
+      program.parameter_blocks();
   for (int i = 0; i < parameter_blocks.size(); ++i) {
     ordering->AddElementToGroup(
         const_cast<double*>(parameter_blocks[i]->user_state()), 0);
diff --git a/internal/ceres/unsymmetric_linear_solver_test.cc b/internal/ceres/unsymmetric_linear_solver_test.cc
index 0b82e6a..b773627 100644
--- a/internal/ceres/unsymmetric_linear_solver_test.cc
+++ b/internal/ceres/unsymmetric_linear_solver_test.cc
@@ -57,8 +57,6 @@
   }
 
   void TestSolver(const LinearSolver::Options& options) {
-
-
     LinearSolver::PerSolveOptions per_solve_options;
     LinearSolver::Summary unregularized_solve_summary;
     LinearSolver::Summary regularized_solve_summary;
@@ -109,7 +107,8 @@
     for (int i = 0; i < A_->num_cols(); ++i) {
       EXPECT_NEAR(sol_unregularized_[i], x_unregularized[i], 1e-8)
           << "\nExpected: "
-          << ConstVectorRef(sol_unregularized_.get(), A_->num_cols()).transpose()
+          << ConstVectorRef(sol_unregularized_.get(),
+                            A_->num_cols()).transpose()
           << "\nActual: " << x_unregularized.transpose();
     }
 
diff --git a/internal/ceres/visibility.cc b/internal/ceres/visibility.cc
index da8beed..9dfb0f4 100644
--- a/internal/ceres/visibility.cc
+++ b/internal/ceres/visibility.cc
@@ -49,6 +49,12 @@
 namespace ceres {
 namespace internal {
 
+using std::make_pair;
+using std::max;
+using std::pair;
+using std::set;
+using std::vector;
+
 void ComputeVisibility(const CompressedRowBlockStructure& block_structure,
                        const int num_eliminate_blocks,
                        vector< set<int> >* visibility) {
diff --git a/internal/ceres/visibility.h b/internal/ceres/visibility.h
index 322efe9..2ef00be 100644
--- a/internal/ceres/visibility.h
+++ b/internal/ceres/visibility.h
@@ -59,7 +59,7 @@
 // points and f_blocks correspond to cameras.
 void ComputeVisibility(const CompressedRowBlockStructure& block_structure,
                        int num_eliminate_blocks,
-                       vector<set<int> >* visibility);
+                       std::vector<std::set<int> >* visibility);
 
 // Given f_block visibility as computed by the ComputeVisibility
 // function above, construct and return a graph whose vertices are
@@ -75,7 +75,7 @@
 // Caller acquires ownership of the returned WeightedGraph pointer
 // (heap-allocated).
 WeightedGraph<int>* CreateSchurComplementGraph(
-    const vector<set<int> >& visibility);
+    const std::vector<std::set<int> >& visibility);
 
 }  // namespace internal
 }  // namespace ceres
diff --git a/internal/ceres/visibility_based_preconditioner.cc b/internal/ceres/visibility_based_preconditioner.cc
index c7ed049..125856e 100644
--- a/internal/ceres/visibility_based_preconditioner.cc
+++ b/internal/ceres/visibility_based_preconditioner.cc
@@ -58,6 +58,12 @@
 namespace ceres {
 namespace internal {
 
+using std::make_pair;
+using std::pair;
+using std::set;
+using std::swap;
+using std::vector;
+
 // TODO(sameeragarwal): Currently these are magic weights for the
 // preconditioner construction. Move these higher up into the Options
 // struct and provide some guidelines for choosing them.
@@ -399,7 +405,7 @@
 // matrix. Scaling these off-diagonal entries by 1/2 forces this
 // matrix to be positive definite.
 void VisibilityBasedPreconditioner::ScaleOffDiagonalCells() {
-  for (set< pair<int, int> >::const_iterator it = block_pairs_.begin();
+  for (set<pair<int, int> >::const_iterator it = block_pairs_.begin();
        it != block_pairs_.end();
        ++it) {
     const int block1 = it->first;
@@ -484,7 +490,7 @@
   int cluster1 = cluster_membership_[block1];
   int cluster2 = cluster_membership_[block2];
   if (cluster1 > cluster2) {
-    std::swap(cluster1, cluster2);
+    swap(cluster1, cluster2);
   }
   return (cluster_pairs_.count(make_pair(cluster1, cluster2)) > 0);
 }
diff --git a/internal/ceres/visibility_based_preconditioner.h b/internal/ceres/visibility_based_preconditioner.h
index 2f6922d..10959d6 100644
--- a/internal/ceres/visibility_based_preconditioner.h
+++ b/internal/ceres/visibility_based_preconditioner.h
@@ -151,15 +151,16 @@
   LinearSolverTerminationType Factorize();
   void ScaleOffDiagonalCells();
 
-  void ClusterCameras(const vector< set<int> >& visibility);
+  void ClusterCameras(const std::vector< std::set<int> >& visibility);
   void FlattenMembershipMap(const HashMap<int, int>& membership_map,
-                            vector<int>* membership_vector) const;
-  void ComputeClusterVisibility(const vector<set<int> >& visibility,
-                                vector<set<int> >* cluster_visibility) const;
+                            std::vector<int>* membership_vector) const;
+  void ComputeClusterVisibility(
+      const std::vector<std::set<int> >& visibility,
+      std::vector<std::set<int> >* cluster_visibility) const;
   WeightedGraph<int>* CreateClusterGraph(
-      const vector<set<int> >& visibility) const;
+      const std::vector<std::set<int> >& visibility) const;
   void ForestToClusterPairs(const WeightedGraph<int>& forest,
-                            HashSet<pair<int, int> >* cluster_pairs) const;
+                            HashSet<std::pair<int, int> >* cluster_pairs) const;
   void ComputeBlockPairsInPreconditioner(const CompressedRowBlockStructure& bs);
   bool IsBlockPairInPreconditioner(int block1, int block2) const;
   bool IsBlockPairOffDiagonal(int block1, int block2) const;
@@ -171,19 +172,19 @@
   int num_clusters_;
 
   // Sizes of the blocks in the schur complement.
-  vector<int> block_size_;
+  std::vector<int> block_size_;
 
   // Mapping from cameras to clusters.
-  vector<int> cluster_membership_;
+  std::vector<int> cluster_membership_;
 
   // Non-zero camera pairs from the schur complement matrix that are
   // present in the preconditioner, sorted by row (first element of
   // each pair), then column (second).
-  set<pair<int, int> > block_pairs_;
+  std::set<std::pair<int, int> > block_pairs_;
 
   // Set of cluster pairs (including self pairs (i,i)) in the
   // preconditioner.
-  HashSet<pair<int, int> > cluster_pairs_;
+  HashSet<std::pair<int, int> > cluster_pairs_;
   scoped_ptr<SchurEliminatorBase> eliminator_;
 
   // Preconditioner matrix.
diff --git a/internal/ceres/visibility_test.cc b/internal/ceres/visibility_test.cc
index 01f2bdf..183ab88 100644
--- a/internal/ceres/visibility_test.cc
+++ b/internal/ceres/visibility_test.cc
@@ -47,6 +47,9 @@
 namespace ceres {
 namespace internal {
 
+using std::set;
+using std::vector;
+
 class VisibilityTest : public ::testing::Test {
 };