diff --git a/include/ceres/ceres.h b/include/ceres/ceres.h
index b28c016..9b8f212 100644
--- a/include/ceres/ceres.h
+++ b/include/ceres/ceres.h
@@ -43,7 +43,7 @@
 #include "ceres/local_parameterization.h"
 #include "ceres/loss_function.h"
 #include "ceres/numeric_diff_cost_function.h"
-#include "ceres/ordering.h"
+#include "ceres/ordered_groups.h"
 #include "ceres/problem.h"
 #include "ceres/sized_cost_function.h"
 #include "ceres/solver.h"
diff --git a/include/ceres/ordered_groups.h b/include/ceres/ordered_groups.h
index 5f41dd4..d9210b3 100644
--- a/include/ceres/ordered_groups.h
+++ b/include/ceres/ordered_groups.h
@@ -28,6 +28,9 @@
 //
 // Author: sameeragarwal@google.com (Sameer Agarwal)
 
+#ifndef CERES_PUBLIC_ORDERED_GROUPS_H_
+#define CERES_PUBLIC_ORDERED_GROUPS_H_
+
 #include <map>
 #include <set>
 #include "ceres/collections_port.h"
@@ -144,3 +147,5 @@
 typedef OrderedGroups<double*> ParameterBlockOrdering;
 
 }  // namespace ceres
+
+#endif  // CERES_PUBLIC_ORDERED_GROUP_H_
diff --git a/include/ceres/ordering.h b/include/ceres/ordering.h
deleted file mode 100644
index c302aad..0000000
--- a/include/ceres/ordering.h
+++ /dev/null
@@ -1,128 +0,0 @@
-// Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are met:
-//
-// * Redistributions of source code must retain the above copyright notice,
-//   this list of conditions and the following disclaimer.
-// * Redistributions in binary form must reproduce the above copyright notice,
-//   this list of conditions and the following disclaimer in the documentation
-//   and/or other materials provided with the distribution.
-// * Neither the name of Google Inc. nor the names of its contributors may be
-//   used to endorse or promote products derived from this software without
-//   specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
-// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-// POSSIBILITY OF SUCH DAMAGE.
-//
-// Author: sameeragarwal@google.com (Sameer Agarwal)
-
-#include <map>
-#include <set>
-#include "ceres/internal/port.h"
-#include "glog/logging.h"
-
-namespace ceres {
-
-// The order in which variables are eliminated in a linear solver can
-// have a significant of impact on the efficiency and accuracy of the
-// method. e.g., when doing sparse Cholesky factorization, there are
-// matrices for which a good ordering will give a Cholesky factor with
-// O(n) storage, where as a bad ordering will result in an completely
-// dense factor.
-//
-// Ceres allows the user to provide varying amounts of hints to the
-// solver about the variable elimination ordering to use. This can
-// range from no hints, where the solver is free to decide the best
-// possible ordering based on the user's choices like the linear
-// solver being used, to an exact order in which the variables should
-// be eliminated, and a variety of possibilities in between. Instances
-// of the Ordering class are used to communicate this infornation to
-// Ceres.
-//
-// Formally an ordering is an ordered partitioning of the parameter
-// blocks, i.e, each parameter block belongs to exactly one group, and
-// each group has a unique integer associated with it, that determines
-// its order in the set of groups.
-//
-// Given such an ordering, Ceres ensures that the parameter blocks in
-// the lowest numbered group are eliminated first, and then the
-// parmeter blocks in the next lowest numbered group and so on. Within
-// each group, Ceres is free to order the parameter blocks as it
-// chooses.
-// e.g. Consider the linear system
-//
-//   x + y = 3
-//   2x + 3y = 7
-//
-// There are two ways in which it can be solved. First eliminating x
-// from the two equations, solving for y and then back substituting
-// for x, or first eliminating y, solving for x and back substituting
-// for y. The user can construct three orderings here.
-//
-//   {0: x}, {1: y} - eliminate x first.
-//   {0: y}, {1: x} - eliminate y first.
-//   {0: x, y}      - Solver gets to decide the elimination order.
-//
-// Thus, to have Ceres determine the ordering automatically using
-// heuristics, put all the variables in group 0 and to control the
-// ordering for every variable, create groups 0..N-1, one per
-// variable, in the desired order.
-//
-// Bundle Adjustment
-// -----------------
-//
-// A particular case of interest is bundle adjustment, where the user
-// has two options. The default is to not specify an ordering at all,
-// the solver will see that the user wants to use a Schur type solver
-// and figure out the right elimination ordering.
-//
-// But if the user already knows what parameter blocks are points and
-// what are cameras, they can save preprocessing time by partitioning
-// the parameter blocks into two groups, one for the points and one
-// for the cameras, where the group containing the points has an id
-// smaller than the group containing cameras.
-class Ordering {
- public:
-  // Add a parameter block to a group with id group_id. If a group
-  // with this id does not exist, one is created. This method can be
-  // called any number of times for a parameter block.
-  void AddParameterBlockToGroup(double* parameter_block, int group_id);
-
-  // Remove the parameter block from the ordering, no matter what
-  // group it is in. If the parameter block is not known to the
-  // ordering, calling this method will result in a crash.
-  void RemoveParameterBlock(double* parameter_block);
-
-  // Return the group id for the parameter block. If the parameter
-  // block is not known to the Ordering, calling this method results
-  // in a crash.
-  int GroupIdForParameterBlock(double* parameter_block) const;
-
-  // This function always succeeds. For a group_id unknown to the
-  // ordering is treated as empty groups and the function returns
-  // zero.
-  int GroupSize(int group_id) const;
-
-  bool ContainsParameterBlock(double* parameter_block) const;
-  int NumParameterBlocks() const;
-  int NumGroups() const;
-  const map<int, set<double*> >& group_id_to_parameter_blocks() const;
-
- private:
-  map<int, set<double*> > group_id_to_parameter_blocks_;
-  map<double*, int>  parameter_block_to_group_id_;
-};
-
-}  // namespace ceres
diff --git a/include/ceres/solver.h b/include/ceres/solver.h
index 7922f1c..e7b6b32 100644
--- a/include/ceres/solver.h
+++ b/include/ceres/solver.h
@@ -38,11 +38,11 @@
 #include "ceres/internal/macros.h"
 #include "ceres/internal/port.h"
 #include "ceres/iteration_callback.h"
+#include "ceres/ordered_groups.h"
 #include "ceres/types.h"
 
 namespace ceres {
 
-class Ordering;
 class Problem;
 
 // Interface for non-linear least squares solvers.
@@ -245,13 +245,14 @@
     // variables should be eliminated, and a variety of possibilities
     // in between.
     //
-    // Instances of the Ordering class are used to communicate this
-    // infornation to Ceres.
+    // Instances of the ParameterBlockOrdering class are used to
+    // communicate this information to Ceres.
     //
-    // Formally an ordering is an ordered partitioning of the parameter
-    // blocks, i.e, each parameter block belongs to exactly one group, and
-    // each group has a unique integer associated with it, that determines
-    // its order in the set of groups.
+    // Formally an ordering is an ordered partitioning of the
+    // parameter blocks, i.e, each parameter block belongs to exactly
+    // one group, and each group has a unique non-negative integer
+    // associated with it, that determines its order in the set of
+    // groups.
     //
     // Given such an ordering, Ceres ensures that the parameter blocks in
     // the lowest numbered group are eliminated first, and then the
@@ -261,8 +262,41 @@
     //
     // If NULL, then all parameter blocks are assumed to be in the
     // same group and the solver is free to decide the best
-    // ordering. (See ordering.h for more details).
-    Ordering* ordering;
+    // ordering.
+    //
+    // e.g. Consider the linear system
+    //
+    //   x + y = 3
+    //   2x + 3y = 7
+    //
+    // There are two ways in which it can be solved. First eliminating x
+    // from the two equations, solving for y and then back substituting
+    // for x, or first eliminating y, solving for x and back substituting
+    // for y. The user can construct three orderings here.
+    //
+    //   {0: x}, {1: y} - eliminate x first.
+    //   {0: y}, {1: x} - eliminate y first.
+    //   {0: x, y}      - Solver gets to decide the elimination order.
+    //
+    // Thus, to have Ceres determine the ordering automatically using
+    // heuristics, put all the variables in group 0 and to control the
+    // ordering for every variable, create groups 0..N-1, one per
+    // variable, in the desired order.
+    //
+    // Bundle Adjustment
+    // -----------------
+    //
+    // A particular case of interest is bundle adjustment, where the user
+    // has two options. The default is to not specify an ordering at all,
+    // the solver will see that the user wants to use a Schur type solver
+    // and figure out the right elimination ordering.
+    //
+    // But if the user already knows what parameter blocks are points and
+    // what are cameras, they can save preprocessing time by partitioning
+    // the parameter blocks into two groups, one for the points and one
+    // for the cameras, where the group containing the points has an id
+    // smaller than the group containing cameras.
+    ParameterBlockOrdering* ordering;
 
     // Some non-linear least squares problems have additional
     // structure in the way the parameter blocks interact that it is