mockingbirdnest
diff --git a/astronomy/geodesy_test.cpp b/astronomy/geodesy_test.cpp
@@ -7,6 +7,7 @@
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include "physics/body_surface_dynamic_frame.hpp"
+#include "physics/discrete_trajectory.hpp"
 #include "physics/solar_system.hpp"
 #include "quantities/si.hpp"
 #include "testing_utilities/approximate_quantity.hpp"

diff --git a/astronomy/lunar_orbit_test.cpp b/astronomy/lunar_orbit_test.cpp
@@ -415,7 +415,8 @@ TEST_P(LunarOrbitTest, NearCircularRepeatGroundTrackOrbit) {
 
   DiscreteTrajectory<LunarSurface> ascending_nodes;
   DiscreteTrajectory<LunarSurface> descending_nodes;
-  ComputeNodes(surface_trajectory.begin(),
+  ComputeNodes(surface_trajectory,
+               surface_trajectory.begin(),
                surface_trajectory.end(),
                /*north=*/Vector<double, LunarSurface>({0, 0, 1}),
                /*max_points=*/std::numeric_limits<int>::max(),
@@ -425,6 +426,7 @@ TEST_P(LunarOrbitTest, NearCircularRepeatGroundTrackOrbit) {
   DiscreteTrajectory<ICRS> apoapsides;
   DiscreteTrajectory<ICRS> periapsides;
   ComputeApsides(*ephemeris_->trajectory(moon_),
+                 trajectory,
                  trajectory.begin(),
                  trajectory.end(),
                  /*max_points=*/std::numeric_limits<int>::max(),
@@ -530,7 +532,7 @@ TEST_P(LunarOrbitTest, NearCircularRepeatGroundTrackOrbit) {
   {
     EccentricityVectorRange actual_period_ends;
     for (int orbit = 0;
-         orbit < descending_nodes.Size();
+         orbit < descending_nodes.size();
          orbit += orbits_per_period) {
       auto& actual = actual_period_ends;
       auto const e = descending_node_eccentricities[orbit];

diff --git a/astronomy/mercury_perihelion_test.cpp b/astronomy/mercury_perihelion_test.cpp
@@ -12,7 +12,6 @@
 #include "integrators/symmetric_linear_multistep_integrator.hpp"
 #include "mathematica/mathematica.hpp"
 #include "physics/degrees_of_freedom.hpp"
-#include "physics/discrete_trajectory.hpp"
 #include "physics/ephemeris.hpp"
 #include "physics/kepler_orbit.hpp"
 #include "physics/massive_body.hpp"
@@ -33,7 +32,6 @@ using geometry::Position;
 using integrators::SymmetricLinearMultistepIntegrator;
 using integrators::methods::QuinlanTremaine1990Order12;
 using physics::ContinuousTrajectory;
-using physics::DiscreteTrajectory;
 using physics::Ephemeris;
 using physics::KeplerianElements;
 using physics::KeplerOrbit;

diff --git a/astronomy/orbit_analysis_test.cpp b/astronomy/orbit_analysis_test.cpp
@@ -14,6 +14,7 @@
 #include "mathematica/mathematica.hpp"
 #include "numerics/polynomial.hpp"
 #include "physics/body_centred_non_rotating_dynamic_frame.hpp"
+#include "physics/discrete_trajectory.hpp"
 #include "physics/ephemeris.hpp"
 #include "physics/solar_system.hpp"
 #include "testing_utilities/approximate_quantity.hpp"

diff --git a/astronomy/orbit_ground_track_body.hpp b/astronomy/orbit_ground_track_body.hpp
@@ -34,11 +34,11 @@ std::vector<Angle> PlanetocentricLongitudes(
     DiscreteTrajectory<PrimaryCentred> const& nodes,
     RotatingBody<Inertial> const& primary) {
   std::vector<Angle> longitudes;
-  longitudes.reserve(nodes.Size());
-  for (auto const& node : nodes) {
+  longitudes.reserve(nodes.size());
+  for (auto const& [time, degrees_of_freedom] : nodes) {
     longitudes.push_back(
-        CelestialLongitude(node.degrees_of_freedom.position()) -
-        primary.AngleAt(node.time) - π / 2 * Radian);
+        CelestialLongitude(degrees_of_freedom.position()) -
+        primary.AngleAt(time) - π / 2 * Radian);
   }
   return longitudes;
 }
@@ -126,18 +126,19 @@ absl::StatusOr<OrbitGroundTrack> OrbitGroundTrack::ForTrajectory(
   DiscreteTrajectory<PrimaryCentred> ascending_nodes;
   DiscreteTrajectory<PrimaryCentred> descending_nodes;
   OrbitGroundTrack ground_track;
-  RETURN_IF_ERROR(ComputeNodes(trajectory.begin(),
+  RETURN_IF_ERROR(ComputeNodes(trajectory,
+                               trajectory.begin(),
                                trajectory.end(),
                                Vector<double, PrimaryCentred>({0, 0, 1}),
                                /*max_points=*/std::numeric_limits<int>::max(),
                                ascending_nodes,
                                descending_nodes));
   if (mean_sun.has_value()) {
-    if (!ascending_nodes.Empty()) {
+    if (!ascending_nodes.empty()) {
       ground_track.mean_solar_times_of_ascending_nodes_ =
           MeanSolarTimesOfNodes(ascending_nodes, *mean_sun);
     }
-    if (!descending_nodes.Empty()) {
+    if (!descending_nodes.empty()) {
       ground_track.mean_solar_times_of_descending_nodes_ =
           MeanSolarTimesOfNodes(descending_nodes, *mean_sun);
     }
@@ -147,7 +148,7 @@ absl::StatusOr<OrbitGroundTrack> OrbitGroundTrack::ForTrajectory(
   ground_track.longitudes_of_equator_crossings_of_descending_passes_ =
       PlanetocentricLongitudes(descending_nodes, primary);
   ground_track.first_descending_pass_before_first_ascending_pass_ =
-      !ascending_nodes.Empty() && !descending_nodes.Empty() &&
+      !ascending_nodes.empty() && !descending_nodes.empty() &&
       descending_nodes.front().time < ascending_nodes.front().time;
   return ground_track;
 }

diff --git a/astronomy/orbital_elements_body.hpp b/astronomy/orbital_elements_body.hpp
@@ -5,6 +5,7 @@
 #include <algorithm>
 #include <vector>
 
+#include "absl/strings/str_cat.h"
 #include "base/jthread.hpp"
 #include "base/status_utilities.hpp"
 #include "physics/kepler_orbit.hpp"
@@ -36,9 +37,9 @@ absl::StatusOr<OrbitalElements> OrbitalElements::ForTrajectory(
     MassiveBody const& primary,
     Body const& secondary) {
   OrbitalElements orbital_elements;
-  if (trajectory.Size() < 2) {
+  if (trajectory.size() < 2) {
     return absl::InvalidArgumentError(
-        "trajectory.Size() is " + std::to_string(trajectory.Size()));
+        absl::StrCat("trajectory.Size() is ", trajectory.size()));
   }
   orbital_elements.osculating_equinoctial_elements_ =
       OsculatingEquinoctialElements(trajectory, primary, secondary);
@@ -144,7 +145,7 @@ OrbitalElements::OsculatingEquinoctialElements(
   DegreesOfFreedom<PrimaryCentred> const primary_dof{
       PrimaryCentred::origin, PrimaryCentred::unmoving};
   std::vector<EquinoctialElements> result;
-  result.reserve(trajectory.Size());
+  result.reserve(trajectory.size());
   for (auto const& [time, degrees_of_freedom] : trajectory) {
     auto const osculating_elements =
         KeplerOrbit<PrimaryCentred>(primary,
@@ -177,7 +178,7 @@ template<typename PrimaryCentred>
 std::vector<Length> OrbitalElements::RadialDistances(
     DiscreteTrajectory<PrimaryCentred> const& trajectory) {
   std::vector<Length> radial_distances;
-  radial_distances.reserve(trajectory.Size());
+  radial_distances.reserve(trajectory.size());
   DegreesOfFreedom<PrimaryCentred> const primary_dof{PrimaryCentred::origin,
                                                      PrimaryCentred::unmoving};
   for (auto const& [time, degrees_of_freedom] : trajectory) {

diff --git a/astronomy/orbital_elements_test.cpp b/astronomy/orbital_elements_test.cpp
@@ -10,6 +10,7 @@
 #include "gtest/gtest.h"
 #include "mathematica/mathematica.hpp"
 #include "physics/body_centred_non_rotating_dynamic_frame.hpp"
+#include "physics/discrete_trajectory.hpp"
 #include "physics/ephemeris.hpp"
 #include "physics/kepler_orbit.hpp"
 #include "physics/solar_system.hpp"

diff --git a/astronomy/standard_product_3.cpp b/astronomy/standard_product_3.cpp
@@ -35,7 +35,7 @@ template<int n>
 not_null<std::unique_ptr<DiscreteTrajectory<ITRS>>> ComputeVelocities(
     DiscreteTrajectory<ITRS> const& arc) {
   auto result = make_not_null_unique<DiscreteTrajectory<ITRS>>();
-  CHECK_GE(arc.Size(), n);
+  CHECK_GE(arc.size(), n);
   std::array<Instant, n> times;
   std::array<Position<ITRS>, n> positions;
   auto it = arc.begin();
@@ -49,7 +49,7 @@ not_null<std::unique_ptr<DiscreteTrajectory<ITRS>>> ComputeVelocities(
   // We use a central difference formula wherever possible, so we keep
   // |offset| at (n - 1) / 2 except at the beginning and end of the arc.
   int offset = 0;
-  for (int i = 0; i < arc.Size(); ++i) {
+  for (int i = 0; i < arc.size(); ++i) {
     result->Append(
         times[offset],
         {positions[offset],
@@ -71,7 +71,7 @@ not_null<std::unique_ptr<DiscreteTrajectory<ITRS>>> ComputeVelocities(
   }
   // Note that having the right number of calls to |Append| does not guarantee
   // this, as appending at an existing time merely emits a warning.
-  CHECK_EQ(result->Size(), arc.Size());
+  CHECK_EQ(result->size(), arc.size());
   return result;
 }
 
@@ -375,7 +375,7 @@ StandardProduct3::StandardProduct3(
 
       // Bad or absent positional and velocity values are to be set to 0.000000.
       if (position == ITRS::origin || velocity == ITRS::unmoving) {
-        if (!arc.Empty()) {
+        if (!arc.empty()) {
           orbit.push_back(make_not_null_unique<DiscreteTrajectory<ITRS>>());
         }
       } else {
@@ -390,7 +390,7 @@ StandardProduct3::StandardProduct3(
   for (auto& [id, orbit] : orbits_) {
     // Do not leave a final empty trajectory if the orbit ends with missing
     // data.
-    if (orbit.back()->Empty()) {
+    if (orbit.back()->empty()) {
       orbit.pop_back();
     }
   }
@@ -403,7 +403,7 @@ StandardProduct3::StandardProduct3(
             arc = ComputeVelocities<n>(*arc); \
             break
 
-        switch (arc->Size()) {
+        switch (arc->size()) {
           COMPUTE_VELOCITIES_CASE(1);
           COMPUTE_VELOCITIES_CASE(2);
           COMPUTE_VELOCITIES_CASE(3);

diff --git a/astronomy/standard_product_3_test.cpp b/astronomy/standard_product_3_test.cpp
@@ -374,28 +374,30 @@ TEST_P(StandardProduct3DynamicsTest, PerturbedKeplerian) {
         if (++it == arc->end()) {
           break;
         }
-      ephemeris_->FlowWithAdaptiveStep(
-            &integrated_arc,
-            Ephemeris<ICRS>::NoIntrinsicAcceleration,
-            it->time,
-            Ephemeris<ICRS>::AdaptiveStepParameters(
-                EmbeddedExplicitRungeKuttaNyströmIntegrator<
-                    DormandالمكاوىPrince1986RKN434FM,
-                    Position<ICRS>>(),
-                std::numeric_limits<std::int64_t>::max(),
-                /*length_integration_tolerance=*/1 * Milli(Metre),
-                /*speed_integration_tolerance=*/1 * Milli(Metre) / Second),
-            /*max_ephemeris_steps=*/std::numeric_limits<std::int64_t>::max());
-      DegreesOfFreedom<ICRS> actual =
-          integrated_arc.back().degrees_of_freedom;
-      DegreesOfFreedom<ICRS> expected =
-          itrs_.FromThisFrameAtTime(it->time)(it->degrees_of_freedom);
-      EXPECT_THAT(AbsoluteError(expected.position(), actual.position()),
-                  Lt(25 * Metre))
-          << "orbit of satellite " << satellite << " flowing from point " << i;
-      EXPECT_THAT(AbsoluteError(expected.velocity(), actual.velocity()),
-                  Lt(1 * Deci(Metre) / Second))
-          << "orbit of satellite " << satellite << " flowing from point " << i;
+        ephemeris_->FlowWithAdaptiveStep(
+              &integrated_arc,
+              Ephemeris<ICRS>::NoIntrinsicAcceleration,
+              it->time,
+              Ephemeris<ICRS>::AdaptiveStepParameters(
+                  EmbeddedExplicitRungeKuttaNyströmIntegrator<
+                      DormandالمكاوىPrince1986RKN434FM,
+                      Position<ICRS>>(),
+                  std::numeric_limits<std::int64_t>::max(),
+                  /*length_integration_tolerance=*/1 * Milli(Metre),
+                  /*speed_integration_tolerance=*/1 * Milli(Metre) / Second),
+              /*max_ephemeris_steps=*/std::numeric_limits<std::int64_t>::max());
+        DegreesOfFreedom<ICRS> actual =
+            integrated_arc.back().degrees_of_freedom;
+        DegreesOfFreedom<ICRS> expected =
+            itrs_.FromThisFrameAtTime(it->time)(it->degrees_of_freedom);
+        EXPECT_THAT(AbsoluteError(expected.position(), actual.position()),
+                    Lt(25 * Metre))
+            << "orbit of satellite " << satellite << " flowing from point "
+            << i;
+        EXPECT_THAT(AbsoluteError(expected.velocity(), actual.velocity()),
+                    Lt(1 * Deci(Metre) / Second))
+            << "orbit of satellite " << satellite << " flowing from point "
+            << i;
       }
     }
   }

diff --git a/astronomy/лидов_古在_test.cpp b/astronomy/лидов_古在_test.cpp
@@ -7,6 +7,7 @@
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include "physics/body_centred_non_rotating_dynamic_frame.hpp"
+#include "physics/discrete_trajectory.hpp"
 #include "physics/solar_system.hpp"
 #include "mathematica/mathematica.hpp"
 #include "testing_utilities/matchers.hpp"
@@ -85,8 +86,9 @@ TEST_F(Лидов古在Test, MercuryOrbiter) {
   DiscreteTrajectory<ICRS> icrs_trajectory;
   icrs_trajectory.Append(MercuryOrbiterInitialTime,
                          MercuryOrbiterInitialDegreesOfFreedom<ICRS>);
-  icrs_trajectory.SetDownsampling({.max_dense_intervals = 10'000,
-                                   .tolerance = 10 * Metre});
+  auto& icrs_segment = icrs_trajectory.segments().front();
+  icrs_segment.SetDownsampling({.max_dense_intervals = 10'000,
+                                .tolerance = 10 * Metre});
   auto const instance = ephemeris_->NewInstance(
       {&icrs_trajectory},
       Ephemeris<ICRS>::NoIntrinsicAccelerations,

diff --git a/base/pull_serializer_test.cpp b/base/pull_serializer_test.cpp
@@ -49,8 +49,7 @@ class PullSerializerTest : public ::testing::Test {
         make_not_null_unique<DiscreteTrajectory>();
     // Build a biggish protobuf for serialization.
     for (int i = 0; i < 100; ++i) {
-      DiscreteTrajectory::InstantaneousDegreesOfFreedom* idof =
-          result->add_timeline();
+      auto* const idof = result->add_timeline();
       Point* instant = idof->mutable_instant();
       Quantity* scalar = instant->mutable_scalar();
       scalar->set_dimensions(3);

diff --git a/base/push_deserializer_test.cpp b/base/push_deserializer_test.cpp
@@ -66,8 +66,7 @@ class PushDeserializerTest : public ::testing::Test {
         make_not_null_unique<DiscreteTrajectory>();
     // Build a biggish protobuf for serialization.
     for (int i = 0; i < 100; ++i) {
-      DiscreteTrajectory::InstantaneousDegreesOfFreedom* idof =
-          result->add_timeline();
+      auto* const idof = result->add_timeline();
       Point* instant = idof->mutable_instant();
       Quantity* scalar = instant->mutable_scalar();
       scalar->set_dimensions(3);

diff --git a/base/status_utilities.hpp b/base/status_utilities.hpp
@@ -19,6 +19,7 @@ absl::Status const& GetStatus(absl::StatusOr<T> const& s) {
 }  // namespace internal_status_utilities
 
 #define CHECK_OK(value) CHECK_EQ((value), ::absl::OkStatus())
+#define DCHECK_OK(value) DCHECK_EQ((value), ::absl::OkStatus())
 #define EXPECT_OK(value) \
   EXPECT_THAT((value), ::principia::testing_utilities::IsOk());
 

diff --git a/benchmarks/apsides.cpp b/benchmarks/apsides.cpp
@@ -16,6 +16,7 @@
 #include "physics/apsides.hpp"
 #include "physics/body_centred_non_rotating_dynamic_frame.hpp"
 #include "physics/body_surface_dynamic_frame.hpp"
+#include "physics/discrete_trajectory.hpp"
 #include "physics/ephemeris.hpp"
 #include "physics/solar_system.hpp"
 #include "quantities/astronomy.hpp"
@@ -135,28 +136,30 @@ BENCHMARK_F(ApsidesBenchmark, ComputeApsides)(benchmark::State& state) {
     DiscreteTrajectory<ICRS> apoapsides;
     DiscreteTrajectory<ICRS> periapsides;
     ComputeApsides(*earth_trajectory_,
+                   *ilrsa_lageos2_trajectory_icrs_,
                    ilrsa_lageos2_trajectory_icrs_->begin(),
                    ilrsa_lageos2_trajectory_icrs_->end(),
                    /*max_points=*/std::numeric_limits<int>::max(),
                    apoapsides,
                    periapsides);
-    CHECK_EQ(2364, apoapsides.Size());
-    CHECK_EQ(2365, periapsides.Size());
+    CHECK_EQ(2364, apoapsides.size());
+    CHECK_EQ(2365, periapsides.size());
   }
 }
 
 BENCHMARK_F(ApsidesBenchmark, ComputeNodes)(benchmark::State& state) {
   for (auto _ : state) {
     DiscreteTrajectory<GCRS> ascending;
     DiscreteTrajectory<GCRS> descending;
-    ComputeNodes(ilrsa_lageos2_trajectory_gcrs_->begin(),
+    ComputeNodes(*ilrsa_lageos2_trajectory_gcrs_,
+                 ilrsa_lageos2_trajectory_gcrs_->begin(),
                  ilrsa_lageos2_trajectory_gcrs_->end(),
                  Vector<double, GCRS>({0, 0, 1}),
                  /*max_points=*/std::numeric_limits<int>::max(),
                  ascending,
                  descending);
-    CHECK_EQ(2365, ascending.Size());
-    CHECK_EQ(2365, descending.Size());
+    CHECK_EQ(2365, ascending.size());
+    CHECK_EQ(2365, descending.size());
   }
 }
 

diff --git a/benchmarks/benchmarks.vcxproj b/benchmarks/benchmarks.vcxproj
@@ -25,6 +25,7 @@
     <ClCompile Include="..\numerics\fast_sin_cos_2π.cpp" />
     <ClCompile Include="..\physics\protector.cpp" />
     <ClCompile Include="apsides.cpp" />
+    <ClCompile Include="discrete_trajectory.cpp" />
     <ClCompile Include="dynamic_frame.cpp" />
     <ClCompile Include="elliptic_integrals_benchmark.cpp" />
     <ClCompile Include="elliptic_functions_benchmark.cpp" />

diff --git a/benchmarks/benchmarks.vcxproj.filters b/benchmarks/benchmarks.vcxproj.filters
@@ -92,6 +92,9 @@
     <ClCompile Include="..\geometry\instant_output.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="discrete_trajectory.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="quantities.hpp">