docs: Revise features.rst

Eliminate sentence fragments, standardize hyphenation of compound modifiers,
and tighten descriptions in features.rst.

Change-Id: I59173afb411a918dcae0fe837fa165c23d063f74
diff --git a/docs/source/features.rst b/docs/source/features.rst
index 171fa3a..2c890b2 100644
--- a/docs/source/features.rst
+++ b/docs/source/features.rst
@@ -7,85 +7,80 @@
 ====
 .. _chapter-features:
 
-* **Code Quality** - Ceres Solver has been used in production at
-  Google since 2010. It is clean, extensively tested and well
-  documented code that is actively developed and supported.
+* **Code Quality.** Ceres Solver has been used in production at Google
+  since 2010. It is clean, extensively tested, and well-documented code
+  that is actively developed and supported.
 
-* **Modeling API** - It is rarely the case that one starts with the
-  exact and complete formulation of the problem that one is trying to
-  solve. Ceres's modeling API has been designed so that the user can
-  easily build and modify the objective function, one term at a
-  time. And to do so without worrying about how the solver is going to
-  deal with the resulting changes in the sparsity/structure of the
-  underlying problem.
+* **Modeling API.** One rarely starts with the exact, final formulation
+  of an optimization problem. Ceres's modeling API lets you build and
+  modify the objective function one term at a time, without worrying
+  about how the solver will handle the resulting changes in sparsity or
+  problem structure.
 
-  - **Derivatives** Supplying derivatives is perhaps the most tedious
-    and error prone part of using an optimization library.  Ceres
-    ships with `automatic`_ and `numeric`_ differentiation. So you
-    never have to compute derivatives by hand (unless you really want
-    to). Not only this, Ceres allows you to mix automatic, numeric and
-    analytical derivatives in any combination that you want.
+  - **Derivatives.** Supplying derivatives is often the most tedious
+    and error-prone part of using an optimization library. Ceres ships
+    with `automatic`_ and `numeric`_ differentiation, so you never have
+    to compute derivatives by hand unless you want to. Ceres also lets
+    you mix automatic, numeric, and analytical derivatives in any
+    combination.
 
-  - **Robust Loss Functions** Most non-linear least squares problems
-    involve data. If there is data, there will be outliers. Ceres
-    allows the user to *shape* their residuals using a
-    :class:`LossFunction` to reduce the influence of outliers.
+  - **Robust Loss Functions.** Most non-linear least squares problems
+    fit models to data, and real data contain outliers. Ceres lets you
+    shape residuals with a :class:`LossFunction` to reduce the
+    influence of outliers.
 
-  - **Manifolds** In many cases, some parameters lie on a manifold
-    other than Euclidean space, e.g., rotation matrices. In such
-    cases, the user can specify the geometry of the local tangent
-    space by specifying a :class:`Manifold` object.
+  - **Manifolds.** Parameters often lie on a nonlinear manifold rather
+    than in Euclidean space, such as rotation matrices in :math:`SO(3)`.
+    You can specify the geometry of the local tangent space using a
+    :class:`Manifold` object.
 
-* **Solver Choice** Depending on the size, sparsity structure, time &
-  memory budgets, and solution quality requirements, different
-  optimization algorithms will suit different needs. To this end,
-  Ceres Solver comes with a variety of optimization algorithms:
+* **Solver Choice.** Different problem sizes, sparsity structures, and
+  time or memory budgets call for different algorithms. Ceres Solver
+  provides both trust-region and line-search optimizers:
 
-  - **Trust Region Solvers** - Ceres supports Levenberg-Marquardt,
-    Powell's Dogleg, and Subspace dogleg methods. The key
-    computational cost in all of these methods is the solution of a
-    linear system. To this end Ceres ships with a variety of linear
-    solvers - dense QR and dense Cholesky factorization (using
-    `Eigen`_, `LAPACK`_ or `CUDA`_) for dense problems, sparse
-    Cholesky factorization (`SuiteSparse`_, `Apple's Accelerate`_,
-    `Eigen`_, `NVIDIA cuDSS`_) for large sparse problems, custom Schur
-    complement based dense, sparse, and iterative linear solvers for
-    `bundle adjustment`_ problems.
+  - **Trust Region Solvers.** Ceres supports Levenberg-Marquardt,
+    Powell's Dogleg, and Subspace Dogleg methods. The dominant
+    computational cost in each iteration is solving a linear least
+    squares system. Ceres ships with linear solvers tailored to major
+    problem classes: dense QR and dense Cholesky factorization (via
+    `Eigen`_, `LAPACK`_, or `CUDA`_) for dense problems; sparse
+    Cholesky factorization (via `SuiteSparse`_, `Apple's Accelerate`_,
+    `Eigen`_, or `NVIDIA cuDSS`_) for general sparse problems; and
+    Schur complement based dense, sparse, and iterative linear solvers
+    for `bundle adjustment`_ problems.
 
-  - **Line Search Solvers** - When the problem size is so large that
-    storing and factoring the Jacobian is not feasible or a low
-    accuracy solution is required cheaply, Ceres offers a number of
-    line search based algorithms. This includes a number of variants
-    of Non-linear Conjugate Gradients, BFGS and LBFGS.
+  - **Line Search Solvers.** When the problem is so large that storing
+    and factoring the Jacobian is infeasible, or when a low-accuracy
+    solution is needed quickly, Ceres offers line search algorithms,
+    including several variants of Non-linear Conjugate Gradients, BFGS,
+    and L-BFGS.
 
-* **Speed** - Ceres Solver has been extensively optimized, with C++
-  templating, hand written linear algebra routines and modern C++
-  threads based multithreading of the Jacobian evaluation and the
-  linear solvers.
+* **Speed.** Ceres Solver is extensively optimized using C++ templates,
+  hand-tuned linear algebra kernels, and multithreaded Jacobian
+  evaluation and linear solvers.
 
-* **GPU Acceleration** - If your system supports `CUDA`_ then Ceres
-  Solver can use the NVIDIA GPU on your system to speed up both dense
-  and sparse linear solvers (including mixed-precision solves and
-  `NVIDIA cuDSS`_ sparse Cholesky factorization).
+* **GPU Acceleration.** On systems with an NVIDIA GPU, Ceres Solver can
+  use `CUDA`_ to accelerate both dense and sparse linear solvers,
+  including mixed-precision solves and sparse Cholesky factorization
+  via `NVIDIA cuDSS`_.
 
-* **Solution Quality** Ceres is the `best performing`_ solver on the
-  NIST problem set used by Mondragon and Borchers for benchmarking
+* **Solution Quality.** Ceres is the `best performing`_ solver on the
+  NIST problem set used by Mondragon and Borchers to benchmark
   non-linear least squares solvers.
 
-* **Covariance estimation** - Evaluate the sensitivity/uncertainty of
-  the solution by evaluating all or part of the covariance
-  matrix. Ceres is one of the few solvers that allows you to do this
+* **Covariance Estimation.** You can evaluate the sensitivity and
+  uncertainty of a solution by computing all or part of its covariance
+  matrix. Ceres is one of the few solvers capable of performing this
   analysis at scale.
 
-* **Community** Since its release as an open source software, Ceres
-  has developed an active developer community that contributes new
-  features, bug fixes and support.
+* **Community.** Since its release as open-source software, Ceres has
+  developed an active developer community that contributes new
+  features, bug fixes, and user support.
 
-* **Portability** - Runs on *Linux*, *Windows*, *macOS*, *Android*
-  *and iOS*.
+* **Portability.** Runs on Linux, Windows, macOS, Android, and iOS.
 
-* **BSD Licensed** The BSD license offers the flexibility to ship your
-  application
+* **BSD Licensed.** The 3-clause BSD license gives you the flexibility
+  to ship Ceres in commercial and open-source applications.
 
 .. _best performing: https://groups.google.com/forum/#!topic/ceres-solver/UcicgMPgbXw
 .. _bundle adjustment: https://en.wikipedia.org/wiki/Bundle_adjustment