How To Figure Out Displacement From A Velocity Time Graph

How to Figure Out Displacement from a Velocity‑Time Graph

Ever stared at a squiggly line on a physics worksheet and wondered, “What does this even mean for how far something actually moved?The short version is: the area under the curve is your answer. Most students can read a speedometer, but turning a velocity‑time graph into a real‑world distance feels like decoding a secret message. But there’s a lot more nuance than just “shade it and add it up.” You’re not alone. ” Let’s walk through the whole process, step by step, and clear up the common confusions that trip up even seasoned learners.

What Is a Velocity‑Time Graph?

A velocity‑time graph (often called a v‑t graph) is a picture

Interpreting the Axes

Because velocity can be positive (motion in the chosen forward direction) or negative (motion opposite that direction), the graph can sit above or below the time axis. This sign matters when you later calculate displacement, because the signed area will tell you whether the object ended up ahead of or behind its starting point.

Why “Area Under the Curve” Equals Displacement

The definition of velocity is the derivative of displacement with respect to time:

[ v(t)=\frac{d s(t)}{dt}. ]

If you rearrange that differential relationship and integrate over a time interval ([t_1, t_2]),

[ \int_{t_1}^{t_2} v(t),dt = s(t_2)-s(t_1)=\Delta s, ]

you see that the integral of velocity—geometrically the signed area under the v‑t curve—gives the change in position, i.e., the displacement.

Key point: “Area” here is signed. A region above the time axis contributes positive displacement, while a region below contributes negative displacement.

Step‑by‑Step Procedure

1. Identify the interval you care about.

   • Are you asked for the total displacement from (t=0) to (t=10) s?
   • Or perhaps the distance traveled between two specific events (e.g., when the object changes direction)?

2. Break the curve into simple shapes (rectangles, triangles, trapezoids, or a combination) The details matter here..

   • Straight‑line segments → triangles or trapezoids.
   • Horizontal sections → rectangles.
   • Curved sections → you may need calculus (definite integral) or a numerical method (e.g., the trapezoidal rule).

3. Calculate the signed area for each piece.

   • Rectangle: (A = \text{base} \times \text{height}).
   • Triangle: (A = \frac{1}{2}\times\text{base}\times\text{height}).
   • Trapezoid: (A = \frac{1}{2}\times(\text{top}+\text{bottom})\times\text{base}).
   • Curved piece: (\displaystyle A \approx \sum_{i=1}^{n}\frac{v_{i}+v_{i+1}}{2},\Delta t_i) (trapezoidal approximation) or evaluate the antiderivative if you have an equation.

4. Assign a sign to each area.

   • If the segment lies above the time axis → positive.
   • If it lies below → negative.

5. Add all signed areas together.
   [ \Delta s = \sum_{k} A_k^{\text{(signed)}}. ]

6. Interpret the result.

   • Displacement ((\Delta s)) can be zero even if the object moved a lot (e.g., a round‑trip).
   • Total distance traveled is the sum of the absolute values of each area, ignoring sign.

Worked Example: A Piecewise Linear Motion

Suppose a car’s velocity over 12 s is described by the following piecewise linear graph:

Step 1 – Interval: We want the displacement from (t=0) to (t=12) s That's the part that actually makes a difference..

Step 2 – Shapes:

• 0–3 s: rectangle (base = 3 s, height = +4 m/s).
• 3–5 s: triangle (base = 2 s, height = +4 m/s to 0).
• 5–8 s: triangle (base = 3 s, height = 0 to –3 m/s).
• 8–12 s: rectangle (base = 4 s, height = –3 m/s).

Step 3 – Areas (signed):

• Rectangle: (A_1 = 3 \times 4 = +12) m.
• Triangle (positive): (A_2 = \frac{1}{2}\times2\times4 = +4) m.
• Triangle (negative): (A_3 = \frac{1}{2}\times3\times(-3) = -4.5) m.
• Rectangle (negative): (A_4 = 4 \times (-3) = -12) m.

Step 4 – Sum:
[ \Delta s = (+12) + (+4) + (-4.5) + (-12) = -0.5;\text{m}. ]

Interpretation: After 12 s the car is 0.5 m behind its starting point Surprisingly effective..

If we instead asked for the total distance traveled, we’d ignore the signs:

[ \text{Distance} = |12| + |4| + |4.5| + |12| = 32.5;\text{m}.

When the Graph Isn’t Made of Straight Lines

1. Analytical Functions

If the velocity is given by an equation, e.g., (v(t)=6\sin(2t)), you can integrate directly:

[ \Delta s = \int_{t_1}^{t_2} 6\sin(2t),dt = -3\cos(2t)\Big|_{t_1}^{t_2}. ]

Plug in the limits and you have the exact displacement.

2. Numerical Approximation

When the function is only known at discrete data points (common in lab work), the trapezoidal rule or Simpson’s rule provides a good estimate:

[ \Delta s \approx \sum_{i=1}^{N-1}\frac{v_i+v_{i+1}}{2},(t_{i+1}-t_i). ]

Modern calculators and spreadsheet software have built‑in functions for this (“=TRAPZ” in Excel, “integrate” in Python’s NumPy, etc.).

Common Pitfalls & How to Avoid Them

Quick Checklist Before You Submit

• [ ] Identify the exact time interval.
• [ ] Determine whether you need displacement (signed) or total distance (absolute).
• [ ] Break the graph into recognizable geometric shapes or write down the velocity function.
• [ ] Compute each area with the correct sign.
• [ ] Sum the signed areas → displacement.
  If distance is required, sum the absolute values instead.
• [ ] Verify units (e.g., m · s⁻¹ × s = m).

Real‑World Applications

1. Navigation systems: GPS devices integrate velocity data from accelerometers to estimate how far a car has traveled between satellite fixes.
2. Sports analytics: Coaches plot a runner’s velocity vs. time to calculate how much ground was covered during each split, then use the area to assess pacing strategies.
3. Engineering diagnostics: Vibration analysis often yields velocity‑time plots; integrating those signals tells you the net displacement of a component during a shock event.

In each case, the same principle—area under the velocity‑time curve—provides a bridge from abstract numbers to concrete motion.

Conclusion

Turning a velocity‑time graph into a meaningful measure of how far something has moved is nothing more mysterious than finding the signed area under the curve. With the checklist and pitfalls outlined above, you can approach any textbook problem—or real‑world data set—with confidence. By carefully breaking the graph into simple shapes (or applying calculus when the function is smooth), assigning the correct sign, and summing the pieces, you obtain the object's displacement. Think about it: the next time you see that squiggly line, you’ll know exactly how to read the hidden story of motion it tells. Remember the distinction between displacement (a vector quantity that can be positive, negative, or zero) and total distance (a scalar that is always positive). Happy calculating!

Easier said than done, but still worth knowing.

A final word of advice: treat every velocity‑time plot as a ledger of “movement credits” and “movement debits.” Positive sections add to the account, negative sections subtract. If the problem asks for total distance, simply ignore the sign and total the absolute values—think of it as tallying every credit and debit regardless of direction. If the problem asks for displacement, let the signs do the work; the result tells you where the object ended up relative to where it started.

By internalising the “area‑under‑the‑curve” concept, you’ll find that many seemingly complex motion questions collapse into a handful of straightforward geometric or calculus steps. Whether you’re solving a high‑school physics worksheet, debugging a robot’s odometry, or interpreting a marathon runner’s split times, the same principle applies: the graph is a visual integral, and the integral is the distance traveled.

With the checklist, the common pitfalls, and the real‑world examples now in your toolbox, you’re equipped to tackle any velocity‑time graph that comes your way—accurately, efficiently, and with confidence. Happy graph‑reading!

4. Numerical integration for irregular data

In many laboratory or field situations you won’t have a neat algebraic expression for v(t); instead you’ll have a table of discrete measurements taken at regular intervals (e.But g. , a data logger recording velocity every 0.1 s). The same “area‑under‑the‑curve” idea still applies—only now you must approximate the area using a numerical integration rule Nothing fancy..

Practical tip: Always keep track of the sign of each velocity value before you sum. If you are interested in total distance, take the absolute value of each term before adding; if you need displacement, add the signed contributions directly Nothing fancy..

5. A step‑by‑step worked example

Suppose a drone’s onboard logger records the following vertical velocities (in m s⁻¹) every 0.5 s during a take‑off and hover maneuver:

Goal: Find (a) the net vertical displacement after 5.5 s, and (b) the total vertical distance travelled.

Solution using the trapezoidal rule

1. Compute the area of each trapezoid:
   (A_i = \frac{1}{2}(v_i+v_{i+1})\Delta t) with Δt = 0.5 s.
2. List the signed contributions:

3. Net displacement = Σ Aᵢ = 0.80 + 2.25 + 3.08 + 3.13 + 2.25 + 0.75 – 0.30 – 0.93 – 1.38 – 1.25 – 0.50 ≈ 8.90 m upward Most people skip this — try not to..

4. Total distance = Σ |Aᵢ| = 0.80 + 2.25 + 3.08 + 3.13 + 2.25 + 0.75 + 0.30 + 0.93 + 1.38 + 1.25 + 0.50 ≈ 16.42 m Took long enough..

The drone rose a net 8.9 m but actually traveled 16.4 m vertically because it dipped down after the hover It's one of those things that adds up..

6. Common extensions and “what‑if” scenarios

7. Quick‑reference cheat sheet

Final Thoughts

The elegance of physics often lies in turning a visual picture into a precise number. A velocity‑time graph is a compact ledger of motion; the “area under the curve” is the accounting entry that tells you exactly how far the object has moved. By mastering the geometric intuition (triangles, rectangles, trapezoids) and the calculus tools (definite integrals, numerical approximations), you gain a universal method that works across disciplines—from the classroom to the cockpit, from sports timing mats to spacecraft telemetry.

Remember the three take‑aways:

1. Signed area = displacement – let positive and negative contributions cancel naturally.
2. Absolute area = total distance – strip away the sign when the problem cares only about “how much ground was covered.”
3. Choose the right integration technique – exact algebraic integration when a formula exists; otherwise, apply the appropriate numerical rule based on data quality and required precision.

Armed with these principles, any velocity‑time plot becomes a straightforward puzzle rather than a mystery. That's why the next time you see that sloping line, picture the slices of area beneath it, add them up, and you’ll instantly know the story of motion hidden within. Happy graph‑reading, and may your calculations always land on the right side of the axis!

8. Common pitfalls and how to avoid them

9. Extending the idea: velocity‑time area in higher dimensions

In two‑dimensional motion, the scalar speed‑time plot still yields the arc length of the trajectory, but it tells you nothing about the directional component of the displacement. To recover the vector displacement you need the velocity vector (\mathbf{v}(t) = \langle v_x(t), v_y(t)\rangle). The area under each component’s time‑graph gives the corresponding coordinate displacement:

[ \Delta x = \int_{t_0}^{t_f} v_x(t),dt, \qquad \Delta y = \int_{t_0}^{t_f} v_y(t),dt . ]

If you only have the magnitude (|\mathbf{v}(t)|) and the heading angle (\theta(t)), you can reconstruct the components on the fly:

[ v_x(t)=| \mathbf{v}(t) |\cos\theta(t), \qquad v_y(t)=| \mathbf{v}(t) |\sin\theta(t), ]

and then integrate each component separately. The geometric interpretation remains the same—each component’s signed area is a projection of the total path onto the corresponding axis Most people skip this — try not to. Turns out it matters..

10. A brief case study: a marathon runner

Scenario – A runner’s speed is recorded every 30 s during a 42.195 km marathon. The data show three distinct phases: a fast start (5 m s⁻¹), a steady cruise (4 m s⁻¹), and a final sprint (5.5 m s⁻¹).

Goal – Estimate total distance covered and verify that it matches the official marathon length.

Steps

1. Plot the speed versus time. The curve is piecewise‑linear, so the trapezoidal rule is ideal.

2. Compute the area of each segment:

   • Start: (A_1 = \frac{30}{2}(5 + 5.2) = 77.0\text{ m}) (the slight increase to 5.2 m s⁻¹ is captured by the first data point).
   • Cruise: 30 intervals of 30 s each at roughly 4 m s⁻¹ → (A_2 = 30 \times 30 \times 4 = 3600\text{ m}).
   • Sprint: last 5 intervals ramp from 4 m s⁻¹ to 5.5 m s⁻¹ → sum of trapezoids ≈ 825 m.

3. Add the areas: (A_{\text{total}} \approx 77 + 3600 + 825 = 4502\text{ m}).

   Because the data were sampled every 30 s, the true distance is a bit larger; applying Simpson’s rule to the middle cruise portion (where the speed is essentially constant) adds a correction of ≈ + 0.This leads to 5 %. The final estimate becomes ≈ 4525 m, confirming that the runner covered the full marathon distance within the expected measurement error.

Easier said than done, but still worth knowing.

Take‑away – Even with coarse sampling, a simple area‑under‑the‑curve calculation provides a reliable check on race statistics, and the same technique scales to any sport where speed logs are available (cycling power meters, GPS‑based skiing, etc.) Worth keeping that in mind..

Conclusion

The “area under a velocity‑time graph” is far more than a textbook illustration; it is a universal, physics‑rooted bookkeeping tool. By treating the graph as a collection of infinitesimal rectangles (or, when convenient, triangles and trapezoids), we translate a visual curve into a precise measure of how far an object has moved. Whether you are solving a textbook integral, processing noisy experimental data, or analyzing telemetry from a spacecraft, the same principles apply:

• Signed area gives the net change in position (displacement).
• Absolute area gives the total ground covered, irrespective of direction.
• Analytic integration is optimal when a closed‑form expression exists, while numerical quadrature (trapezoidal, Simpson’s, higher‑order methods) bridges the gap when data are discrete or the function is unwieldy.

Keeping an eye on sign conventions, unit consistency, and the appropriate choice of integration technique ensures that the calculation is both accurate and meaningful. Still, with these tools at hand, any velocity‑time plot becomes a transparent ledger of motion—one that you can read, interpret, and, most importantly, trust. Happy integrating!

Extending the Toolbox: When the Curve Gets Messier

In many real‑world scenarios the velocity trace is neither a clean piecewise‑linear ladder nor a neat sinusoid. Plus, think of a mountain‑bike descent with sudden skids, a sprinter’s erratic burst in the final 100 m, or a spacecraft executing a series of thrust‑pulses. In those cases the same fundamental idea—area under the curve—still applies, but we must adapt our numerical strategy to capture the subtleties.

1. Adaptive Quadrature

If the data set contains regions of rapid change (high curvature) interspersed with long stretches of near‑constant speed, a uniform step size wastes computational effort on the flat portions while under‑resolving the spikes. Now, adaptive quadrature algorithms (e. But g. , adaptive Simpson’s rule) recursively subdivide intervals until a prescribed error tolerance is met.

And yeah — that's actually more nuanced than it sounds.

1. Apply Simpson’s rule on an interval ([t_i, t_{i+2}]) to obtain an estimate (S).
2. Split the interval at the midpoint, apply Simpson’s rule on the two halves to obtain (S_1+S_2).
3. If (|S-(S_1+S_2)| < 15\epsilon) (where (\epsilon) is the user’s tolerance), accept (S_1+S_2); otherwise, recurse on each half.

Because the algorithm concentrates points where the velocity curve bends sharply, the resulting distance estimate often reaches machine‑precision accuracy with far fewer function evaluations than a fixed‑step method.

2. Spline Integration

When the raw data are noisy, fitting a smooth interpolant before integrating can dramatically improve accuracy. Cubic splines are a popular choice because they guarantee continuity of both the function and its first derivative, which mirrors the physical expectation that velocity does not jump instantaneously (except at idealised impulses).

The steps are:

1. Fit a cubic spline (v_{\text{spline}}(t)) through the measured points ((t_k, v_k)) Which is the point..

2. Integrate the spline analytically. A cubic spline on each sub‑interval ([t_k, t_{k+1}]) has the form

   [ v_{\text{spline}}(t)=a_k (t-t_k)^3 + b_k (t-t_k)^2 + c_k (t-t_k) + d_k, ]

   whose integral is simply

   [ \int_{t_k}^{t_{k+1}} v_{\text{spline}}(t),dt = \frac{a_k}{4}\Delta t^4 + \frac{b_k}{3}\Delta t^3 + \frac{c_k}{2}\Delta t^2 + d_k \Delta t, ]

   where (\Delta t = t_{k+1}-t_k).

3. Sum the contributions from all intervals.

Because the spline captures the underlying trend while smoothing out high‑frequency noise, the integrated distance is strong against measurement jitter—a frequent problem with GPS‑derived speed profiles Small thing, real impact..

3. Handling Signed vs. Absolute Area in Practice

Most sports‑tracking apps report “distance travelled” rather than “net displacement,” but some scientific contexts (e.g., particle tracking in a magnetic field) care about the signed integral Worth knowing..

import numpy as np

# v(t) sampled at uniform dt
v = np.array([...])
dt = 0.1  # seconds

# signed distance
signed = np.sum(v) * dt

# absolute distance
absolute = np.sum(np.abs(v)) * dt

If the sampling is non‑uniform, replace dt with the actual interval array np.diff(t). This approach works regardless of whether the underlying integration was performed analytically, via Simpson’s rule, or through a spline It's one of those things that adds up..

4. Propagating Uncertainty

When the velocity measurements carry known uncertainties (e.Practically speaking, g. , ±0.2 m s⁻¹ from a pitot tube), the integrated distance inherits a statistical spread Took long enough..

[ \sigma_D^2 = \sum_{k} (\sigma_{v,k},\Delta t_k)^2. ]

If the errors are correlated—common in GPS where a bias can persist over several seconds—more sophisticated covariance matrices are required, but the principle remains: integrate the error in the same way you integrate the signal. Now, reporting (D \pm \sigma_D) gives a transparent picture of confidence, a habit that is especially valuable in scientific publications and high‑stakes engineering (e. g., launch vehicle trajectory verification) Surprisingly effective..

A Quick Recap of the Most Useful Formulas

You'll probably want to bookmark this section.

Final Thoughts

The elegance of the “area‑under‑the‑velocity‑time curve” lies in its universality: a single geometric concept bridges pure mathematics, laboratory physics, athletic performance analysis, and aerospace navigation. By selecting the integration technique that matches the character of your data—analytic for tidy formulas, Simpson’s or trapezoidal for evenly spaced samples, adaptive quadrature for wildly changing speeds, and splines for noisy measurements—you extract the true distance with confidence and clarity.

The official docs gloss over this. That's a mistake.

Remember, the graph itself is a ledger; the integral is the audit. Treat it with the same rigor you would any measurement: mind the signs, respect the units, quantify the uncertainty, and choose the numerical tool that honors the shape of the curve. When you do, the velocity‑time plot stops being a static picture and becomes a powerful, quantitative narrative of motion The details matter here..

Happy integrating, and may your future calculations always add up correctly!

6. When the Data Are Irregularly Sampled

In many real‑world situations—field surveys, vehicle telematics, or satellite downlinks—the timestamps are not evenly spaced. The simple (\Delta t) factor that makes the trapezoidal and Simpson formulas look so tidy disappears, and we must treat each interval individually Simple as that..

6.1 Piecewise Linear Approximation (Generalized Trapezoid)

If the velocity is assumed linear between two successive measurements ((t_i, v_i)) and ((t_{i+1}, v_{i+1})), the contribution of that segment is

[ \Delta D_i = \frac{v_i + v_{i+1}}{2},\bigl(t_{i+1} - t_i\bigr). ]

Summing over all (N-1) intervals gives the total distance:

[ D ;=; \sum_{i=0}^{N-2} \frac{v_i + v_{i+1}}{2},\bigl(t_{i+1} - t_i\bigr). ]

No requirement for a constant (\Delta t) appears; each interval simply carries its own width That alone is useful..

6.2 Higher‑Order Polynomial Fit on Unequal Grids

When the spacing varies dramatically, a piecewise linear model may be too crude. One can fit a low‑order polynomial (usually quadratic) to a local cluster of points that share a similar time scale. For a three‑point cluster ((t_{i-1},v_{i-1}), (t_i,v_i), (t_{i+1},v_{i+1})) the Lagrange interpolant is

Not the most exciting part, but easily the most useful Less friction, more output..

[ p_i(t) = v_{i-1},\frac{(t-t_i)(t-t_{i+1})}{(t_{i-1}-t_i)(t_{i-1}-t_{i+1})} + v_i,\frac{(t-t_{i-1})(t-t_{i+1})}{(t_i-t_{i-1})(t_i-t_{i+1})} + v_{i+1},\frac{(t-t_{i-1})(t-t_i)}{(t_{i+1}-t_{i-1})(t_{i+1}-t_i)} . ]

Integrating (p_i(t)) from (t_{i-1}) to (t_{i+1}) yields a more accurate contribution than the trapezoid, especially when the velocity curve is curved. In practice, you slide this three‑point window across the data set, accumulating the integrated pieces. This is essentially a non‑uniform Simpson rule And it works..

6.3 Adaptive Quadrature on Irregular Grids

If you already have an irregular grid but still want the rigor of adaptive Simpson’s, you can re‑sample the data onto a temporary uniform mesh using interpolation (linear, spline, or higher‑order) and then run the standard adaptive algorithm on that mesh. The extra interpolation step adds negligible cost compared with the gain in accuracy for highly nonlinear signals.

7. Practical Implementation Tips

Most guides skip this. Don't.

8. Extending Beyond One Dimension

So far we have treated a scalar speed (v(t)). In many applications the object moves in a plane or space, and the velocity vector (\mathbf{v}(t) = (v_x(t),v_y(t),v_z(t))) is known. The path length (total distance traveled) is still the integral of the speed—the magnitude of the velocity vector:

Honestly, this part trips people up more than it should Simple, but easy to overlook..

[ D = \int_{t_0}^{t_f} |\mathbf{v}(t)|,dt = \int_{t_0}^{t_f} \sqrt{v_x^2(t)+v_y^2(t)+v_z^2(t)},dt . ]

When the components are sampled, you first compute the speed at each timestamp:

[ s_i = \sqrt{v_{x,i}^2 + v_{y,i}^2 + v_{z,i}^2}, ]

and then feed the series ({s_i}) into any of the scalar integration schemes described earlier. If you need the displacement vector (the net change in position), you integrate each component without taking the magnitude:

[ \Delta \mathbf{r} = \biggl(\int v_x,dt,; \int v_y,dt,; \int v_z,dt\biggr). ]

Thus the same toolbox serves both scalar distance and vector displacement—just pay attention to whether you take the norm before or after integration.

9. A Real‑World Example: Drone Flight Logging

Consider a hobbyist who records a quadcopter’s velocity at 50 Hz using an onboard IMU. The raw log contains timestamps (seconds), body‑frame velocities (m/s), and a GPS‑derived ground speed for validation. The goal is to estimate the total flight distance.

1. Pre‑process – Convert body‑frame velocities to earth‑frame using the recorded orientation quaternion; drop any NaNs.
2. Smooth – Apply a 5‑point Savitzky‑Golay filter (order 2) to the speed magnitude to suppress high‑frequency vibration noise.
3. Integrate – Because the sampling is uniform, use Simpson’s rule (odd number of points after trimming the start/stop padding).

   import numpy as np
   from scipy.integrate import simpson
   
   t = log['time'].Here's the thing — values          # shape (N,)
   speed = np. Practically speaking, linalg. Plus, norm(v_earth, axis=1)
   distance = simpson(speed, t)
   

4. Because of that, Uncertainty – The IMU spec lists a 0. 02 m/s RMS noise. Propagate as
   (\sigma_D = \sqrt{\sum (\sigma_v \Delta t)^2}), which for 50 Hz yields roughly 0.7 m over a 10‑minute flight. In practice, 5. Consider this: Result – distance = 2 342 ± 0. Because of that, 7 m. The GPS total‑track distance (computed by summing haversine distances between successive GPS fixes) reads 2 339 m, confirming the integration pipeline.

This workflow exemplifies how the theory presented above translates directly into a repeatable, trustworthy measurement pipeline.

10. Concluding Remarks

The problem “How far did the object travel?” is deceptively simple because the answer is hidden in an integral. Whether you have a clean analytical expression, a perfectly uniform data set, or a jagged, noisy time series, the same conceptual steps apply:

1. Understand the nature of the data (continuous vs. discrete, uniform vs. irregular, noisy vs. clean).
2. Choose an integration strategy that respects that nature—analytic, trapezoidal, Simpson’s, adaptive, or spline‑based.
3. Mind the sign if you need net displacement, or take absolute values for total path length.
4. Quantify uncertainty so that the final number carries a confidence interval.
5. Validate against a known case or an independent measurement.

When these habits become routine, the velocity‑time graph stops being a static illustration and becomes a precise accounting tool that can be trusted in research papers, engineering design reviews, and everyday performance tracking alike And it works..

Takeaway: Integrate the error as carefully as you integrate the signal, and the distance you report will be as solid as the data you started with.

Happy integrating, and may every curve you encounter yield its true length Turns out it matters..