Python 加速二维点

我有以下Python代码：

import math

x = 0
y = 0

acceleration = 10
angle = 0

vx = 0
vy = 0

time = 10
for _ in range(time):
    vx += acceleration * math.cos(math.radians(angle))
    vy += -acceleration * math.sin(math.radians(angle))

    x += vx
    y += vy

print(x, y)

哪些产出：

550.0.0

这不是位移方程的结果

（加速*时间**2）/2

=500

---

我做错了什么？我想不用时间解决问题；假装它不存在

在您的情况下，

x

和

y

应使用

vx

初始值和最终值的平均值进行更新 速度和vy分别为

vy

作为

如果每一步都需要x和y，你应该这样做

import math

x = 0
y = 0

acceleration = 10
angle = 0

vx = 0
vy = 0

time = 10

vx = (vx + acceleration * math.cos(math.radians(angle))*time)/2 #average of velocity
vy = (vy  -acceleration * math.sin(math.radians(angle))*time)/2 #average of velocity

for _ in range(time):

  x += vx
  y += vy

  print(x, y)

---

在您的情况下，

x

和

y

应使用

vx

初始值和最终值的平均值进行更新 速度和vy分别为

vy

作为

如果每一步都需要x和y，你应该这样做

import math

x = 0
y = 0

acceleration = 10
angle = 0

vx = 0
vy = 0

time = 10

vx = (vx + acceleration * math.cos(math.radians(angle))*time)/2 #average of velocity
vy = (vy  -acceleration * math.sin(math.radians(angle))*time)/2 #average of velocity

for _ in range(time):

  x += vx
  y += vy

  print(x, y)

---

你要做的是找到速度随时间的精确积分，其中速度本身隐含着加速度积分。您可以尝试使用最简单的方法来实现这一点：方法。累积误差是不可避免的

除了Euler方法固有的错误（不精确）之外，您的实现还有以顺序方式更新变量的错误。i、 e:将过去的位移与当前速度相结合，而不是与相应的过去速度相结合。您应该计算每个变量的新值，并同时更新它们。例如（从代码中省略常量）：

在当前设置（使用修复程序）中，模拟的运行方式如下：

通过增加时间分辨率可以获得更好的结果，例如，将步长设置为0.1而不是1，可以得到：

如果您对更好的数值积分方法感兴趣，请访问wikipedia或

以下是重现绘图的代码：

import numpy as np                                                                                                                                                                                                 
import matplotlib.pyplot as plt                                                                                                                                                                                    

acceleration = 10                                                                                                                                                                                                  

t0 = 0                                                                                                                                                                                                             
t1 = 10                                                                                                                                                                                                            
nb_steps = 11                                                                                                                                                                                                      

ts = np.linspace(t0, t1, num=nb_steps)                                                                                                                                                                             
vs = np.zeros_like(ts)                                                                                                                                                                                             
xs = np.zeros_like(ts)                                                                                                                                                                                             

vs[0] = 0                                                                                                                                                                                                          
xs[0] = 0                                                                                                                                                                                                          

true_xs = acceleration * ts ** 2 / 2                                                                                                                                                                               


for i, t in enumerate(ts):                                                                                                                                                                                         
    if i == 0:                                                                                                                                                                                                     
        continue # initial conditions are preset                                                                                                                                                                   

    delta_t = t - ts[i-1]                                                                                                                                                                                          
    vs[i] = vs[i-1] + acceleration * delta_t                                                                                                                                                                       
    xs[i] = xs[i-1] + vs[i-1] * delta_t                                                                                                                                                                            

plt.figure()                                                                                                                                                                                                       
plt.plot(ts, vs, label='velocity')                                                                                                                                                                                 
plt.plot(ts, xs, label='displacement-sim')                                                                                                                                                                         
plt.plot(ts, true_xs, label='displacement-true')                                                                                                                                                                   
plt.legend()                                                                                                                                                                                                       
plt.show()                                                                                                                                                                                                         

---

你要做的是找到速度随时间的精确积分，其中速度本身隐含着加速度积分。您可以尝试使用最简单的方法来实现这一点：方法。累积误差是不可避免的

除了Euler方法固有的错误（不精确）之外，您的实现还有以顺序方式更新变量的错误。i、 e:将过去的位移与当前速度相结合，而不是与相应的过去速度相结合。您应该计算每个变量的新值，并同时更新它们。例如（从代码中省略常量）：

在当前设置（使用修复程序）中，模拟的运行方式如下：

通过增加时间分辨率可以获得更好的结果，例如，将步长设置为0.1而不是1，可以得到：

如果您对更好的数值积分方法感兴趣，请访问wikipedia或

以下是重现绘图的代码：

import numpy as np                                                                                                                                                                                                 
import matplotlib.pyplot as plt                                                                                                                                                                                    

acceleration = 10                                                                                                                                                                                                  

t0 = 0                                                                                                                                                                                                             
t1 = 10                                                                                                                                                                                                            
nb_steps = 11                                                                                                                                                                                                      

ts = np.linspace(t0, t1, num=nb_steps)                                                                                                                                                                             
vs = np.zeros_like(ts)                                                                                                                                                                                             
xs = np.zeros_like(ts)                                                                                                                                                                                             

vs[0] = 0                                                                                                                                                                                                          
xs[0] = 0                                                                                                                                                                                                          

true_xs = acceleration * ts ** 2 / 2                                                                                                                                                                               


for i, t in enumerate(ts):                                                                                                                                                                                         
    if i == 0:                                                                                                                                                                                                     
        continue # initial conditions are preset                                                                                                                                                                   

    delta_t = t - ts[i-1]                                                                                                                                                                                          
    vs[i] = vs[i-1] + acceleration * delta_t                                                                                                                                                                       
    xs[i] = xs[i-1] + vs[i-1] * delta_t                                                                                                                                                                            

plt.figure()                                                                                                                                                                                                       
plt.plot(ts, vs, label='velocity')                                                                                                                                                                                 
plt.plot(ts, xs, label='displacement-sim')                                                                                                                                                                         
plt.plot(ts, true_xs, label='displacement-true')                                                                                                                                                                   
plt.legend()                                                                                                                                                                                                       
plt.show()                                                                                                                                                                                                         

---

为什么要使用循环并使其复杂化things@Shubham沙斯瓦特：也许我应该澄清一下：这只是说明问题。事实上，我有一个对象，它每一步都会更新。公式是精确的，而你做一个线性近似。（严重）舍入误差不可避免。

角度

从不改变；您可以在循环外预计算正弦和余弦。@dedObed:这不是舍入错误。这是一个逻辑错误。为什么要使用循环并使其复杂化things@Shubham沙斯瓦特：也许我应该澄清一下：这只是说明问题。事实上，我有一个对象，它每一步都会更新。公式是精确的，而你做一个线性近似。（严重）舍入误差不可避免。

角度

从不改变；您可以在循环外预计算正弦和余弦。@dedObed:这不是舍入错误。这是一个逻辑错误。我已经更新了我的请求，因为我不想用“时间”来解决问题。你没有回答“我做错了什么？”这个问题，你只是把位移方程包装成一个循环。我更新了我的请求，因为我不想用“时间”来解决这个问题。你没有回答“我做错了什么？”这个问题，你只是将位移方程包装在一个循环中。半隐式或辛欧拉方法也是一个一阶方法，在某些情况下，如轨道力学，定性上比显式或隐式欧拉方法更正确。它离Verlet方法只有半步之遥，而Verlet方法对于机械系统来说甚至更好。因此，说问题代码未能实现显式Euler方法是正确的，但说它绝对错误是错误的。谢谢。这是一个很好的答案。我不知道这些事情有什么办法；我认为它们是精确的。我还有一件事要问：在我的代码中，当我将起始速度设置为

vx=-acceleration*math.cos（math.radians（angle））/2

和

vy=acceleration*math.sin（math.radians（angle））/2

时，我似乎得到了正确和精确的（x，y）结果（以不正确的速度为代价）。为什么？半隐式或辛欧拉方法也是一阶方法，在某些情况下，如轨道力学，定性上比显式或隐式欧拉方法更正确。它离Verlet方法只有半步之遥，而Verlet方法对于机械系统来说甚至更好。因此，说问题代码未能实现显式Euler方法是正确的，但说它绝对错误是错误的。谢谢。这是一个很好的答案。我不知道这些事情有什么办法；我认为它们是精确的。我还有一件事要问：在我的代码中，当我将起始速度设置为

vx=-acceleration*math.cos（math.radians（angle））/2

和

vy=acceleration*math.sin（math.radians（angle））/2

时，我似乎得到了正确和精确的（x，y）结果（以不正确的速度为代价）。为什么呢？