如何计算负加速度？

Question

我正在实现触摸屏 UI 的滚动行为，但我现在太累了，无法将注意力集中在一些看似微不足道的数学片段上：

y (distance/velocity)
|********
|        ******
|              ****
|                  ***
|                     ***
|                        **
|                          **
|                            *
|                             *
-------------------------------- x (time)

f(x)->？

UI 应该允许用户向任何方向拖动和“抛出”视图，并且即使在手指从屏幕上松开后也能保持视图滚动一段时间。它的动量取决于用户在松开手指之前拖动的速度。

所以我有一个起始速度 (v0)，并且每 20 毫秒我滚动一个相对于当前速度的量。每次滚动迭代时，我都会稍微降低速度，直到停止时速度降至阈值以下。当我将其减少固定量（线性）时，它看起来不太正确，因此我需要对负加速度进行建模，但无法想出一个像样的简单公式来计算我必须降低速度的量在每次迭代中。

更新：

感谢您迄今为止的回复，但我仍然无法从反馈中得出令人满意的函数。我可能没有足够好地描述所需的解决方案，所以我将尝试给出一个现实世界的例子来说明我想要做的计算：

假设有一辆汽车在某条街道上行驶，并且驾驶员将刹车踩到最大，直到汽车停下来。驾驶员在同一条街道上多次使用同一辆车进行此操作，但开始以不同的速度制动。当汽车减速时，我希望能够仅根据当前速度计算出一秒钟后的速度。对于此计算，当驾驶员开始刹车时汽车行驶的速度并不重要，因为所有环境因素保持不变。当然，公式中会有一些常数，但是当汽车速度降至 30 m/s 时，无论驾驶员开始刹车时的速度是 100 还是 50 m/s，下一秒它都会行驶相同的距离。因此，自到达中断点以来的时间也不会成为该函数的参数。某个速度下的减速度总是相同的。

在这种情况下，假设减速度、质量、摩擦力等任意常数并忽略空气阻力等复杂影响，如何计算一秒钟后的速度？我只追求动能以及由于汽车破裂时的摩擦而耗散的动能。

更新2 我现在看到汽车的加速度是线性的，这实际上不是我想要的。明天我会清理这个并尝试新的建议。感谢您迄今为止的投入。

Answer 1

[简短回答（假设C语法）]

double v(double old_v, double dt) {
    t = t_for(old_v); 
    new_t = t - dt; 
    return (new_t <= 0)?0:v_for(t);
} 

double t_for(double v) 和 double v_for(double t)是 v 到 t 双向映射（数学意义上的函数）的返回值，它是任意的，但具有单调性并为 v >=0 定义（因此有一点其中v=0）。一个例子是：

double v_for(double t) { return pow(t, k); }
double t_for(double v) { return pow(v, 1.0/k); }

其中，

1. k>1 给出减速度随着时间的推移以模数减小。
2. k<1 给出随时间流逝以模数增加的减速度。
3. k=1 提供恒定的减速度。

[更长的一个（带有基本原理和图表）]

所以目标本质上是：

1. 找到一个函数v(t+dt)=f(v(t),dt) 它采用当前速度值 v 和时间增量 dt 并返回 t+dt 时刻的速度（它不需要实际上指定 t，因为 v(t) 已知并作为参数提供，而 dt 只是时间增量）。 换句话说，任务是实现具有特定属性的例程 double next_v(curr_v, dt);（见下文）。

2. [请注意]所讨论的函数有一个有用的（和期望的）属性，无论先前速度变化的“历史”如何，都会返回相同的结果。这意味着，例如，如果一系列连续速度为 [100, 50, 10, 0]（对于起始速度 v0=100），则任何其他大于此的序列都将具有相同的“tail”：[150, 100, 50, 10, 0]（对于起始速度v0=150）等换句话说，无论起始速度如何，所有速度-时间图实际上都是彼此的副本，只是沿着时间轴偏移各自的值（参见下图，注意线之间的图部分t=0.0和 t=2.0 相同）。

3. 此外，加速度w(t)=dv(t)/dt必须是时间t的递减函数（为了视觉上美观和“直观”我们在此建模的移动 GUI 对象的行为）。

建议的想法是：

1. 首先选择具有所需属性的单调速度函数（在您的情况下，它逐渐减小加速度，但如下面的示例所示，使用“加速”更容易）。 此函数不得还有上限，以便您可以将其用于任何较大的速度值。此外，它必须有一个速度为零的点。一些例子是：v(t) = k*t（不完全是你的情况，因为减速度k在这里是常数），v=sqrt(-t) （这个没问题，在区间 t <= 0 上定义）。

2. 然后，对于任何给定的速度，您可以在上述函数的绘图上找到具有该速度值的点（将会有一个点，因为该函数没有绑定，并且只有一个点，因为它是单调的），按时间增量前进朝向较小的速度值，从而获取下一个。迭代将逐渐（并且不可避免地）将您带到速度为零的点。

3. 基本上就是这样，甚至不需要生成一些“最终”公式，对时间值或初始（不是当前）速度的依赖消失，编程变得非常简单 .

对于两个简单的情况，这个小 python 脚本生成下面的图（给出的初始速度为 1.0 到 10.0），并且，如您所见，来自任何给定的速度“水平”和“向下”，绘图“表现”相同，这是理所当然的，因为无论以什么速度开始减慢（减速），你沿着同一条曲线“移动”相对于速度为零的点：

import numpy
import pylab

import math


class VelocityCurve(object):
    """
    An interface for the velocity 'curve'.
    Must represent a _monotonically_ _growing_
        (i.e. with one-to-one correspondence
        between argument and value) function
        (think of a deceleration reverse-played)
    Must be defined for all larger-than-zero 'v' and 't'
    """
    def v(self, t):
        raise NotImplementedError

    def t(self, v):
        raise NotImplementedError



class VelocityValues(object):

    def __init__(self, v0, velocity_curve):
        assert v0 >= 0
        assert velocity_curve

        self._v = v0
        self._vc = velocity_curve

    def next_v(self, dt):
        t = self._vc.t(self._v)
        new_t = t - dt

        if new_t <= 0:
            self._v = 0
        else:
            self._v = self._vc.v(new_t)

        return self._v


class LinearVelocityCurve(VelocityCurve):

    def __init__(self, k):
        """k is for 'v(t)=k*t'"""
        super(LinearVelocityCurve, self).__init__()

        self._k = k

    def v(self, t):
        assert t >= 0
        return self._k*t

    def t(self, v):
        assert v >= 0
        return v/self._k


class RootVelocityCurve(VelocityCurve):

    def __init__(self, k):
        """k is for 'v(t)=t^(1/k)'"""
        super(RootVelocityCurve, self).__init__()

        self._k = k

    def v(self, t):
        assert t >= 0
        return math.pow(t, 1.0/self._k)

    def t(self, v):
        assert v >= 0
        return math.pow(v, self._k)


def plot_v_arr(v0, velocity_curve, dt):
    vel = VelocityValues(v0, velocity_curve)
    v_list = [v0]

    while True:
        v = vel.next_v(dt)
        v_list.append(v)

        if v <= 0:
            break

    v_arr = numpy.array(list(v_list))
    t_arr = numpy.array(xrange(len(v_list)))*dt

    pylab.plot(t_arr, v_arr)


dt = 0.1

for v0 in range(1, 11):
    plot_v_arr(v0, LinearVelocityCurve(1), dt)

for v0 in range(1, 11):
    plot_v_arr(v0, RootVelocityCurve(2), dt)


pylab.xlabel('Time ')
pylab.ylabel('Velocity')

pylab.grid(True)

pylab.show()

这给出了以下图（线性减速（即恒定减速）的线性图，“曲线” -- 对于“平方根”的情况（参见上面的代码））：

另请请注意，要运行上述脚本，需要安装 pylab、numpy 等（但仅限于绘图部分，“核心”类不依赖任何内容，当然可以单独使用）。

PS 通过这种方法，人们可以真正“构建”（例如，针对不同的t间隔增强不同的功能，甚至平滑手绘（记录的）“人体工程学”曲线）他喜欢的“阻力” :)

Answer 2

看了大家的评论，我想修改一下我的答案：
将速度乘以 k < 1，如k = 0.955，使其呈指数衰减。

解释（带有图表和可调方程！）如下...

我将原始问题中的图表解释为显示速度保持在起始值附近，然后逐渐迅速减小。但如果你想象将一本书滑过桌子，它会迅速远离你，然后减慢速度，然后慢慢停下来。我同意 @Chris Farmer 的观点，即正确使用的模型是与速度成正比的阻力模型。我将采用这个模型并得出我上面建议的答案。我提前为本文的篇幅表示歉意。我确信数学更好的人可以大大简化这个过程。 另外，我直接将图表的链接放入其中，链接中有些字符是 SO 解析器不喜欢的。
URL 现已修复。

我将使用以下定义：

x -> time
a(x) -> acceleration as a function of time
v(x) -> velocity as a function of time
y(x) -> position as a function of time
u -> constant coefficient of drag
colon : denotes proportionality

我们知道阻力产生的力与速度成正比。我们还知道力与加速度成正比。

a(x) : -u v(x)        (Eqn. 1)

负号确保加速度与当前行进方向相反。

我们知道速度是加速度的积分。

v(x) : integral( -u v(x) dx )        (Eqn. 2)

这意味着速度与其自身的积分成正比。我们知道e^x满足这个条件。所以我们假设

v(x) : e^(-u x)        (Eqn. 3)

指数中的阻力系数是这样的，当我们求解方程式中的积分时， 2 u 取消返回方程。 3.

现在我们需要计算出u的值。正如 @BlueRaja 指出的，无论 x 如何，e^x 永远不等于 0。但当 x 足够负时，它接近于零。让我们考虑“停止”原始速度的 1%（您对阈值的想法），假设我们希望在 x = 2 秒内停止（您可以稍后调整）。然后我们需要解决

e^(-2u) = 0.01        (Eqn. 4)

导致我们计算

u = -ln(0.01)/2 ~= 2.3        (Eqn. 5)

让我们绘制v(x)的问题。

看起来它在 2 秒内呈指数衰减到一个小值。到目前为止，一切都很好。

我们不一定想在 GUI 中计算指数。我们知道我们可以轻松地转换指数基数，

e^(-u x) = (e^-u)^x        (Eqn. 6)

我们也不想以秒为单位记录时间。我们知道更新率为 20 毫秒，因此我们定义一个时间周期 n，其周期速率为 50 周期/秒。

n = 50 x        (Eqn. 7)

代入等式中的 u 值。 5代入方程式。 6、结合方程。 7，并代入方程。 3，我们得到

v(n) : k^n, k = e^(ln(0.01)/2/50) ~= 0.955        (Eqn. 8)

让我们用新的x轴以时间为单位绘制它。

同样，我们的速度函数与在所需的迭代次数中衰减到 1%，并遵循“在摩擦影响下滑行”模型。现在我们可以将初始速度 v0 乘以方程： 8 获取任意时间步的实际速度 n：

v(n) = v0 k^n        (Eqn. 9)

请注意，在实现中，没有必要跟踪 v0！我们可以将封闭形式 v0 * k^n 转换为递归以获得最终答案

v(n+1) = v(n)*k        (Eqn. 10)

这个答案满足您不关心初始速度是什么 - 下一个速度的约束始终可以仅使用当前速度进行计算。

值得检查以确保位置行为有意义。遵循这种速度模型的位置是

y(n) = y0 + sum(0..n)(v(n))        (Eqn. 11)

方程中的总和。 11 使用方程 9 的形式可以轻松求解。使用索引变量 p：

sum(p = 0..n-1)(v0 k^p) = v0 (1-k^n)/(1-k)        (Eqn. 12)

所以我们有

y(n) = y0 + v0 (1-k^n)/(1-k)        (Eqn. 13)

让我们用 y0 = 0 和 v0 绘制它= 1.

因此，我们看到快速远离原点，沿着优雅的海岸线到达终点。我相信这张图比你原来的图更忠实地描述了滑动。

一般来说，您可以使用方程调整k

k = e^(ln(Threshold)/Time/Tickrate)        (Eqn. 14)
where:
Threshold is the fraction of starting velocity at which static friction kicks in
Time is the time in seconds at which the speed should drop to Threshold
Tickrate is your discrete sampling interval

（感谢@poke演示了Wolfram Alpha在绘图中的使用 - 这非常好。）

旧答案

将速度乘以 k < 1，如k = 0.98，使其呈指数衰减。

Answer 3

当汽车减速时，我希望能够仅根据当前速度计算出一秒后的速度。

这就是加速度的定义。例如，如果加速度为 a = -9 米/秒/秒，现在的速度为 20 米/秒，那么 1 秒后速度将为11米/秒。

换句话说，从现在到 t 秒后的速度 Δv 变化（假设加速度恒定）将是

Δv = a*t

表示给定 处的初始速度，任何时间 t 的速度的（经典物理）方程t=0 （该速度称为 v₀）

v(t) = v₀+ a*t

---

利用您在前两周微积分课程中学到的知识，您还可以从上面的方程得到x(t)的方程（汽车在时间t时的距离）；这会给你

x(t) = x₀+ v₀*t + 0.5*a *t²

（也可以在不使用微积分的情况下得出此结果，请参阅此处)

---

最后，如果您是为了游戏而不是物理模拟（意味着您不需要精确的结果）执行此操作，您将需要简单地更改位置和速度每一帧，而不是每一帧重新计算位置。为此，您需要在每一帧执行以下操作，假设速度（和加速度）以每秒像素（-每秒）为单位测量：

velocity_new = velocity_old + acceleration/frames_per_second
position_new = position_old + velocity_old/frames_per_second

Answer 4

似乎您正在寻找随着时间的推移而增加的减速度。

尝试计算

Delta_v = -(A*t + B) ，选择适合您的合理常数 A 和 B。

t 是到该点的总时间。

通过添加 Delta_v 来更改速度。

这基本上对应于线性负加速度。

您基本上可以选择任何随时间增加的函数（例如 f(t)）

并计算

Delta_v = -f(t)

f(t) 的适当选择将为您提供所需的效果。

您可以使用的一些示例：

f(t) = At + B.
f(t) = A*exp(Bt)

当然，您必须稍微尝试一下并尝试找出正确的常量。

Answer 5

您可以在每次迭代时将速度降低一个恒定量。示例：您以 50 的速度开始，下一次迭代为 40，然后是 30、20、10，停止。这将代表一个恒定的“摩擦”，与速度无关，这实际上非常接近现实（参见摩擦在维基百科上）。

如果您不喜欢这种外观，则需要使摩擦力取决于速度。我假设线性关系摩擦力=基础摩擦力+（系数*速度），具有相当小的系数，就足够了。

Answer 6

如果您想要增加减速度，正如您在 mtrw 的答案中评论中所说的那样，并且您对物理现实主义不是很挑剔，那么下面的方程式可能就是您正在寻找的：

V(t+dt) = V(t) - K1 + K2 x V(t)

V(t)= 当前速度
V(t+dt)=下一次增量时的速度
K1 和 K2 是您校准的常数。只需确保 (K2 x Vmax) < K1，否则你会高速加速。

如果还是感觉不合适，请尝试
V(t+dt) = V(t) - K1 + K2 xf(V(t))

其中 f(x) 是您选择的单调递增函数，可能是平方或平方根，具体取决于您想要的感觉。只需确保 (K2 xf(V(t))) < K1 对于每个可能的 V(t)。

（单调递增函数意味着当 x 增加时 f(x) 总是增加）

Answer 7

我也会添加一个想法。看起来您不想要恒定（负）加速度。这将产生如下方程：

v(t) = v(0) + a*t,

其中 a 是负加速度，t 是时间，v(t) 是时间上的速度t。这给你：

v(t2) - v(t1) = a(t2-t1),

这意味着对于给定的 Δt，速度差等于 aΔt，一个常数。

您可能正在寻找“摩擦”术语，它取决于当前速度。在这个假设下，速度的变化率与当前速度成正比：

d v(t) / d t = -b*v(t).

解决上述问题很容易，你可以得到：v(t) = v(0) e^{−b t}。

对这个方程进行积分，我们得到 x(t) = v(0)(1−e^{−b t}) / b，其中 x 是位置。 v(0) = 1, b = 0.1 的位置图¹ 看起来像您可以使用的东西。您可能想要调整 b 的值，并在方程中添加比例因子。

---

¹ http://www.wolframalpha.com/input/?i=plot+%281+-+1+e^%28-0.1+x%29+%29+%2F +0.1+for+x+%3D+0+到+100

Answer 8

速度的非线性变化意味着加速度不是恒定的。非恒定加速度意味着系统受到jerk。取出所有加速度方程并添加“(1/6)jt³”。固定 a，并给 ja 一个小的负值，直到 v 达到 0。

Answer 9

您可以跟踪速度并每次将其降低速度的一小部分。我相信这可以很好地模拟摩擦力。

Answer 10

我会将速度降低为 v=v*0.9
然后我会有一个被认为是停止速度的速度。这样，物体最终会静止下来，而不会在移动时继续消耗资源。
所以像
for(v=起始速度;v<1.0;v*=0.9)
{
x+=v；
}

Answer 11

加速度是速度的一阶导数和距离的二阶导数。对于某些常数 C 和 k，您的图看起来像二阶抛物线，类似于 Ck*x^2。如果 y 确实是距离，则需要 a=-2k，如果 y 是速度，则需要 a=-2kx。无论哪种情况，速度 v(x) = V0 + a(x)*x。 （其中 x 实际上是时间。我遵循您的约定，而不使用 t。）

Answer 12

我已经尝试过这个，它有效（在 Ruby 中）。不确定数学是否合理，但输出看起来正确，这意味着当你接近中心时你会变得更快：

velocity=100;
(100.downto(0)).each { |distance_from_black_hole |  velocity=velocity+9.8/distance_from_black_hole; puts velocity; }

Answer 13

关于汽车示例的一些非编程讨论。

首先，我假设驾驶员无法在高速行驶时锁定刹车。

大多数新驾驶员学到的第一件事（或者可能是第二件事或第三件事）是制动时的自然趋势是将制动踏板保持在固定位置。结果是汽车从缓慢行驶到停止时突然向前倾斜。发生这种情况是因为制动器正在从动态摩擦（制动力与制动压力成正比）转变为静态摩擦（制动力恢复汽车的前进动力）。这种突然的加速跳跃令人不快，新驾驶员学会在减速结束时轻踩踏板以停止。

这种行为掩盖了另一个特殊性，但在手动变速箱汽车的正常加速过程中可以注意到这一点。当加速（或减速）时，如果驾驶员突然松开变速箱，所有乘客都会突然向前倾斜。实际发生的情况是，将他们压入座椅靠背的加速力突然消失，他们弹回中立的坐姿。更舒适的驾驶方式是逐渐轻踩离合器，从而逐渐消除发动机的动力。

在这两种情况下，更美观的驾驶风格包括平滑加速，消除突然的跳跃。这基本上是谈论连续二阶导数的另一种方式。几乎任何具有这种性质的运动都会显得很自然。

Answer 14

y(x) = y0 - a * e ^ ( k * x )

其中，y0 是起始常量，a 和 k 是因子。

示例图。

Answer 15

acceleration = (force / mass) 
velocity = (acceleration * time)
(force from user's finger) = acceleration / mass = velocity / time

1. 给视图一个质量（调整它直到事情看起来合理，然后让用户调整它）
2. 识别一些新的力（阻力）
3. 给新的力（阻力）一个大小（调整直到合理，让用户调整它）
4. 应用新的力 （阻力）对物体施力并观察其减速