Add euler

include/EulerSolver.hpp

@@ -0,0 +1,12 @@
+#pragma once
+
+#include "ISolver.hpp"
+
+class EulerSolver : public ISolver
+{
+public:
+    void Step(
+        IRocket& rocket,
+        State& state,
+        double dt) const override;
+};

include/IRocket.hpp

@@ -1,4 +1,6 @@
 #pragma once
+
+#include <Eigen/Dense>
 #include "State.hpp"
 
 class IRocket {

include/ISolver.hpp

@@ -1,10 +1,16 @@
 #pragma once
+
 #include "IRocket.hpp"
 #include "State.hpp"
 
-class ISolver {
+class ISolver
+{
 public:
     virtual ~ISolver() = default;
 
-    virtual State Step(IRocket& rocket, const State& current, double dt) = 0;
-};
+    virtual void Step(
+        IRocket& rocket,
+        State& state,
+        double dt) const = 0;
+};
+

include/RK4Solver.hpp

@@ -0,0 +1,12 @@
+#pragma once
+
+#include "ISolver.hpp"
+
+class RK4Solver : public ISolver
+{
+public:
+    void Step(
+        IRocket& rocket,
+        State& state,
+        double dt) const override;
+};

src/solvers/EulerSolver.cpp

@@ -0,0 +1,14 @@
+#include "EulerSolver.hpp"
+
+void EulerSolver::Step(
+    IRocket& rocket,
+    State& state,
+    double dt) const
+{
+    Eigen::VectorXd dx = rocket.GetDerivatives(state);
+
+    State derivative(state.size());
+    derivative.data = dx;
+
+    state = state + derivative * dt;
+}

src/solvers/RK4Solver.cpp

@@ -0,0 +1,31 @@
+#include "RK4Solver.hpp"
+
+void RK4Solver::Step(
+    IRocket& rocket,
+    State& state,
+    double dt) const
+{
+    const State x = state;
+
+    // k1
+    State k1(x.size());
+    k1.data = rocket.GetDerivatives(x);
+
+    // k2
+    State x2 = x + k1 * (dt * 0.5);
+    State k2(x.size());
+    k2.data = rocket.GetDerivatives(x2);
+
+    // k3
+    State x3 = x + k2 * (dt * 0.5);
+    State k3(x.size());
+    k3.data = rocket.GetDerivatives(x3);
+
+    // k4
+    State x4 = x + k3 * dt;
+    State k4(x.size());
+    k4.data = rocket.GetDerivatives(x4);
+
+    // Final RK4 update
+    state = x + (k1 + k2 * 2.0 + k3 * 2.0 + k4) * (dt / 6.0);
+}