Runge-Kutta 방법을 2 차 ODE에 적용

오일러 방법을 Runge-Kutta 4 차 순서로 대체하여 일정한 중력 크기가 아닌 자유 낙하 운동을 결정하려면 어떻게해야합니까 (예 : 지상 10,000km에서 자유 낙하)?

지금까지 나는 오일러 방법으로 간단한 통합을 작성했습니다.

while()
{
    v += getMagnitude(x) * dt;
    x += v * dt;
    time += dt;
}

x 변수는 현재 위치를, v는 속도를, getMagnitude (x)는 x 위치에서 가속을 반환합니다.

RK4 구현을 시도했습니다.

while()
{
    v += rk4(x, dt) * dt; // rk4() instead of getMagintude()
    x += v * dt;
    time += dt;
}

rk4 () 함수 본문은 다음과 같습니다.

inline double rk4(double tx, double tdt)
{
   double k1 = getMagnitude(tx);
   double k2 = getMagnitude(tx + 0.5 * tdt * k1);
   double k3 = getMagnitude(tx + 0.5 * tdt * k2);
   double k4 = getMagnitude(tx + tdt * k3);

   return (k1 + 2*k2 + 2*k3 + k4)/6.0;
}

그러나 RK4 (가속)를 사용하여 한 번만 통합하기 때문에 무언가 잘못되었습니다. RK4를 사용한 속도 통합은 v * dt와 같기 때문에 의미가 없습니다.

Runge-Kutta 적분을 사용하여 2 차 미분 방정식을 푸는 방법을 알려주시겠습니까? k1, l1, k2, l2 ... l4 계수를 계산하여 RK4를 구현해야합니까? 어떻게해야합니까?

2 단계 이상의 ODE 또는 ODE 시스템에 다단계 (예 : Runge-Kutta) 방법을 적용하는 방법에 대해서는 약간의 혼동이있는 것 같습니다. 프로세스는 일단 이해하면 매우 간단하지만, 설명이 없으면 명확하지 않을 수 있습니다. 다음 방법은 내가 찾은 가장 간단한 방법입니다.

$F = m\ddot{x}$

$v$$x$k1k4$(x,v)$

while (t<TMAX)
    k1 = RHS( t, X );
    k2 = RHS( t + dt / 2, X + dt / 2 * k1 );
    k3 = RHS( t + dt / 2, X + dt / 2 * k2 );
    k4 = RHS( t + dt, X + dt * k3 );
    X = X + dt / 6 * ( k1 + 2 * k2 + 2 * k3 + k4 );
    t = t + dt;
end

X$=(x,v)$RHS( t, X )$(\dot{x}(t),\dot{v}(t))$

불행히도 C ++은 이와 같은 벡터 연산을 기본적으로 지원하지 않으므로 벡터 라이브러리를 사용하거나 루프를 사용하거나 별도의 부분을 수동으로 작성해야합니다. C ++에서는 std::valarray동일한 효과를 얻기 위해 사용할 수 있습니다 . 일정한 가속도를 가진 간단한 작업 예가 있습니다.

#include <valarray>
#include <iostream>

const size_t NDIM = 2;

typedef std::valarray<double> Vector;

Vector RHS( const double t, const Vector X )
{
  // Right hand side of the ODE to solve, in this case:
  // d/dt(x) = v;
  // d/dt(v) = 1;
  Vector output(NDIM);
  output[0] = X[1];
  output[1] = 1;
  return output;
}

int main()
{

  //initialize values

  // State variable X is [position, velocity]
  double init[] = { 0., 0. };
  Vector X( init, NDIM );

  double t = 0.;
  double tMax=5.;
  double dt = 0.1;

  //time loop
  int nSteps = round( ( tMax - t ) / dt );
  for (int stepNumber = 1; stepNumber<=nSteps; ++stepNumber)
  {

    Vector k1 = RHS( t, X );
    Vector k2 = RHS( t + dt / 2.0,  X + dt / 2.0 * k1 );
    Vector k3 = RHS( t + dt / 2.0, X + dt / 2.0 * k2 );
    Vector k4 = RHS( t + dt, X + dt * k3 );

    X += dt / 6.0 * ( k1 + 2.0 * k2 + 2.0 * k3 + k4 );
    t += dt;
  }
  std::cout<<"Final time: "<<t<<std::endl;
  std::cout<<"Final position: "<<X[0]<<std::endl;
  std::cout<<"Final velocity: "<<X[1]<<std::endl;

}