From d347534ff28c9c12e5fc1f657a0c610c4e2bce49 Mon Sep 17 00:00:00 2001
From: Nguyen Quy Anh <23906-nguyenquy@users.noreply.gitlab.inf.ethz.ch>
Date: Fri, 27 Mar 2026 17:20:55 +0100
Subject: [PATCH 1/4] Baseline

---
 .clang-format  |   1 +
 .clangd        |   2 +
 board.hpp      |   9 ++++
 forces.cpp     | 120 +++++++++++++++++++++++++++++++++++++++++
 forces.hpp     |  50 +++++++++++++++++
 main.cpp       | 144 ++++++++++++++++++++++---------------------------
 pedestrian.hpp |  85 +++++++++++++++++++++++++++++
 tsc_x86.h      |  94 ++++++++++++++++++++++++++++++++
 vector2d.hpp   |  24 +++++++++
 9 files changed, 450 insertions(+), 79 deletions(-)
 create mode 100644 .clang-format
 create mode 100644 .clangd
 create mode 100644 board.hpp
 create mode 100644 forces.cpp
 create mode 100644 forces.hpp
 create mode 100644 pedestrian.hpp
 create mode 100644 tsc_x86.h
 create mode 100644 vector2d.hpp

diff --git a/.clang-format b/.clang-format
new file mode 100644
index 0000000..5b02c5e
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1 @@
+ColumnLimit: 1000
diff --git a/.clangd b/.clangd
new file mode 100644
index 0000000..edfd275
--- /dev/null
+++ b/.clangd
@@ -0,0 +1,2 @@
+CompileFlags:
+  Add: [-std=c++23]
\ No newline at end of file
diff --git a/board.hpp b/board.hpp
new file mode 100644
index 0000000..6ee78b4
--- /dev/null
+++ b/board.hpp
@@ -0,0 +1,9 @@
+#pragma once
+#include "vector2d.hpp"
+
+struct Board {
+  double length, width;
+  Vector2d *borders; // array containing the position of each obstacle
+  int n_borders;     // number of obstacles
+  Board(double l, double w, int n, Vector2d *border) : length(l), width(w), n_borders(n), borders(border) {}
+};
diff --git a/forces.cpp b/forces.cpp
new file mode 100644
index 0000000..b48d0d0
--- /dev/null
+++ b/forces.cpp
@@ -0,0 +1,120 @@
+#include "forces.hpp"
+#include <math.h>
+
+// # Done
+double w(Vector2d e, Vector2d f) {
+  if (e.dot(f) >= f.norm() * cos_phi)
+    return 1.0;
+  return c;
+}
+
+// # Done
+//
+// $\vec{F}_\alpha(\vec{v}_\alpha, v^0_\alpha \vec{e}_\alpha) \vec{e}_\alpha(t) = \frac{1}{\tau_\alpha}(v^0_\alpha \vec{e}_\alpha - \vec{v}_\alpha)$
+//
+void compute_acceleration_term(Pedestrian *p) {
+
+  // $v_{\alpha}^{0}\vec{e}_{\alpha}$
+  Vector2d desired_velocity = p->e * p->desired_v0;
+
+  // $\vec{v}_{\alpha}(t)$
+  Vector2d actual_velocity = p->curr_vel;
+
+  double tau_alpha_inv = 1 / tau_alpha;
+
+  p->F_i += (desired_velocity - actual_velocity) * tau_alpha_inv;
+}
+
+// # Done
+//
+// $\sum_{\beta} \vec{F}_{\alpha\beta}(\vec{e}_{\alpha}, \vec{r}_{\alpha} - \vec{r}_{\beta})$
+//
+
+void compute_repulsive_effects_from_pedestrians(Pedestrian *pedestrians, Pedestrian *p, int N) {
+
+  for (int i = 0; i < N; i++) {
+
+    if (pedestrians + i == p)
+      continue;
+
+    // # Optional: Do not consider far away pedestrians from current pedestrian
+    // # Might get better speed up, remove if not
+    // if ((pedestrians[i].curr_pos - p->curr_pos).norm() > DISTANCE) {
+    //   continue;
+    // }
+
+    // $\vec{r}_{\alpha\beta}$
+    Vector2d r_ab = p->curr_pos - pedestrians[i].curr_pos;
+
+    // $\Arrowvert \vec{r}_{\alpha \beta} \Arrowvert$
+    double r_ab_norm = r_ab.norm();
+
+    // $\vec{e}_{\beta}$
+    Vector2d e_beta = pedestrians[i].e;
+
+    // $v_\beta \Delta t$
+    double v_beta_delta_t = pedestrians[i].desired_v0 * delta_t;
+
+    // $\vec{r}_{\alpha\beta} - \vec{v}_{\beta}\varDelta_{t}\vec{e}_{\beta}$
+    Vector2d r_ab_minus_v_beta_delta_t_e_beta = r_ab - (e_beta * v_beta_delta_t);
+
+    // $\Arrowvert \vec{r}_{\alpha \beta} - v_\beta \Delta t \vec{e}_\beta \Arrowvert$
+    double r_ab_minus_v_beta_delta_t_e_beta_norm = r_ab_minus_v_beta_delta_t_e_beta.norm();
+
+    // (4):
+    //
+    // $2b = \sqrt{(\Arrowvert \vec{r}_{\alpha \beta} \Arrowvert + \Arrowvert \vec{r}_{\alpha \beta} - v_\beta \Delta t \vec{e}_\beta \Arrowvert)^2 - (v_\beta \Delta t)^2}$
+    //
+
+    double b = sqrt((r_ab_norm + r_ab_minus_v_beta_delta_t_e_beta_norm) * (r_ab_norm + r_ab_minus_v_beta_delta_t_e_beta_norm) - (v_beta_delta_t) * (v_beta_delta_t)) / 2;
+
+    // (7):
+    //
+    // $\grad_{\vec{r}_{\alpha \beta}}b = \frac{(\Arrowvert \vec{r}_{\alpha \beta} \Arrowvert + \Arrowvert \vec{r}_{\alpha \beta} - v_\beta \Delta t \vec{e}_\beta \Arrowvert) (\frac{\vec{r}_{\alpha \beta}}{\Arrowvert \vec{r}_{\alpha \beta} \Arrowvert} + \frac{\vec{r}_{\alpha \beta} - v_\beta \Delta t \vec{e}_\beta}{\Arrowvert \vec{r}_{\alpha \beta} - v_\beta \Delta t \vec{e}_\beta \Arrowvert})}{4b}$
+    //
+    //
+    Vector2d delta_r_alpha_beta_b = (((r_ab / r_ab_norm) + (r_ab_minus_v_beta_delta_t_e_beta / r_ab_minus_v_beta_delta_t_e_beta_norm)) * (r_ab_norm + r_ab_minus_v_beta_delta_t_e_beta_norm)) / (4 * b);
+
+    // (5):
+    //
+    // $\vec{f}_{\alpha \beta}(\vec{r}_{\alpha \beta}) = \frac{V^0_{\alpha \beta}}{\sigma}e^{-b / \sigma} \grad_{\vec{r}_{\alpha \beta}}b$
+    //
+    //
+    Vector2d f_alpha_beta_r_alpha_beta = delta_r_alpha_beta_b * ((V0_AB / SIGMA) * (exp(-b / SIGMA)));
+
+    // (11):
+    //
+    // $\vec{F}_{\alpha\beta}(\vec{e}_{\alpha}, \vec{r}_{\alpha} - \vec{r}_{\beta}) = w(\vec{e}_{\alpha}, -\vec{f}_{\alpha\beta})\vec{f}_{\alpha\beta}(\vec{r}_{\alpha} - \vec{r}_{\beta})$
+    //
+    // Add repulsive effects from other pedestrians to current pedestrian's social force
+    p->F_i += f_alpha_beta_r_alpha_beta * w(p->e, f_alpha_beta_r_alpha_beta * -1);
+  }
+}
+
+// # Done
+void compute_repulsive_effects_from_borders(Board &B, Pedestrian *p) {
+
+  Vector2d *borders = B.borders;
+  int n_borders = B.n_borders;
+
+  for (int i = 0; i < n_borders; i++) {
+
+    Vector2d border = borders[i];
+
+    // $\vec{r}_{\alpha B}$
+    Vector2d r_alpha_B = p->curr_pos - border;
+
+    //
+    // $\vec{F}_{\alpha B}(\vec{r}_{\alpha B}) = \frac{U^0_{\alpha B}}{R} e^{- \Arrowvert \vec{r}_{\alpha B} \Arrowvert / R} \frac{\vec{r}_{\alpha B}}{\Arrowvert \vec{r}_{\alpha B} \Arrowvert}$
+    //
+
+    Vector2d F_alpha_B = (r_alpha_B / r_alpha_B.norm()) * (U0_AB / R) * std::exp(-r_alpha_B.norm() / R);
+
+    // (12):
+    // 
+    // $\vec{F}_{\alpha B}(\vec{e}_{\alpha}, \vec{r}_{\alpha} - \vec{r}_{ B}) = w(\vec{e}_{\alpha}, -\vec{F}_{\alpha B})\vec{F}_{\alpha B}(\vec{r}_{\alpha} - \vec{r}_{ B})$
+    // 
+
+    p->F_i += F_alpha_B * w(p->e, F_alpha_B * (-1));
+  }
+}
diff --git a/forces.hpp b/forces.hpp
new file mode 100644
index 0000000..27cc042
--- /dev/null
+++ b/forces.hpp
@@ -0,0 +1,50 @@
+#pragma once
+#include "board.hpp"
+#include "pedestrian.hpp"
+#include <cmath>
+
+// $\tau_{\alpha}$
+// https://arxiv.org/pdf/cond-mat/9805244, page 8
+const double tau_alpha = 0.5;
+
+// $V^0_{\alpha \beta}$
+// https://arxiv.org/pdf/cond-mat/9805244, page 8
+const double V0_AB = 2.1;
+
+// $\sigma$
+// https://arxiv.org/pdf/cond-mat/9805244, page 8
+const double SIGMA = 0.3;
+
+// $U^0_{\alpha B}$
+// https://arxiv.org/pdf/cond-mat/9805244, page 8
+const double U0_AB = 10.0;
+
+// $R$
+// https://arxiv.org/pdf/cond-mat/9805244, page 8
+const double R = 0.2;
+
+// $c$
+// https://arxiv.org/pdf/cond-mat/9805244, page 8
+const double c = 0.5;
+
+// $\varphi$
+// https://arxiv.org/pdf/cond-mat/9805244, page 8
+const double phi = 100.0;
+
+const double cos_phi = cos(phi);
+
+// $\varDelta_{t}$
+// step size = 0.2 seconds
+// https://arxiv.org/pdf/cond-mat/9805244, page 8
+const double delta_t = 2;
+
+// # Optional (forces.cpp: compute_repulsive_effects_from_pedestrians)
+// const double DISTANCE = 2.0;
+
+double w(Vector2d e, Vector2d f);
+
+void compute_acceleration_term(Pedestrian *p);
+
+void compute_repulsive_effects_from_pedestrians(Pedestrian *P, Pedestrian *p, int N);
+
+void compute_repulsive_effects_from_borders(Board &B, Pedestrian *p);
diff --git a/main.cpp b/main.cpp
index 248d4f6..2e6035b 100644
--- a/main.cpp
+++ b/main.cpp
@@ -1,103 +1,89 @@
-#include <cfloat>
-#include <iostream>
-#include <math.h>
+#include "board.hpp"
+#include "forces.hpp"
+#include "math.h"
+#include "pedestrian.hpp"
+#include "vector2d.hpp"
+
+double g(double v_max_alpha, double w_alpha_norm) {
+  if (w_alpha_norm <= v_max_alpha) {
+    return 1;
+  }
+  return v_max_alpha / w_alpha_norm;
+}
 
 using namespace std;
 
-struct Vector2d {
-  double x, y;
-  Vector2d(double a, double b) : x(a), y(b) {}
-  Vector2d() : x(.0), y(.0) {}
-  Vector2d operator+(Vector2d v) const { return Vector2d(v.x + x, v.y + y); }
-  Vector2d operator-(Vector2d v) const { return Vector2d(x - v.x, y - v.y); }
-  Vector2d operator-(double a) const { return Vector2d(x - a, y - a); }
-  Vector2d operator+(double a) const { return Vector2d(x + a, y + a); }
-  Vector2d operator/(double a) const { return Vector2d(x / a, y / a); }
-  Vector2d operator*(double a) const { return Vector2d(x * a, y * a); }
-  Vector2d operator+=(const Vector2d &v) {
-    *this = *this + v;
-    return *this;
-  }
-  double norm() { return sqrt(x * x + y * y); }
-  double dot(Vector2d v) { return x * v.x + y * v.y; }
-  void reset() {
-    x = 0;
-    y = 0;
-  }
-};
-
 // Numer of pedestrians
 // $n_p$
-const int n_p = 100;
+// const int n_p = 100;
 
 // Number of iterations
 // $n_{iter}$
-const int n_iter = 100;
+// const int n_iter = 100;
 
-// TODO: Change this
-// $\tau$
-const double tau = 0.12345;
-
-void compute_acceleration_term(Vector2d *F_i) {}
-void compute_repulsive_effects_from_pedestrians(Vector2d *F_i) {}
-void compute_repulsive_effects_from_borders(Vector2d *F_i) {}
-
-// Return an array of doubles
-double *w(Vector2d e, Vector2d f) {
-
-  // TODO:
-  // $cos(60\degree)$
-  // if (e * f > f.norm() * (0.5)) {
-  // }
-  // return 0;
+Pedestrian *init_pedestrians(int n_p) {
+  Pedestrian *P = new Pedestrian[n_p];
+  for (int i = 0; i < n_p; i++) {
+    P[i] = Pedestrian();
+  }
+  return P;
 }
 
-int main() {
+Board init_board(int width, int length) {
+  Vector2d obs[] = {Vector2d(2.0, 1.0), Vector2d(4.0, 1.0), Vector2d(6.0, 2.0), Vector2d(6.0, 4.0)};
+  return Board(width, length, 4, obs);
+}
 
-  // ! DONT TOUCH
+int main(int argc, const char* argv[]) {
 
-  // $\vec{v}^0_i$
-  // Velocity at iteration $t$ for pedestrian $i$
-  double v[n_iter][n_p];
+  Board B = init_board(10, 15);
 
-  // $\vec{r}^0_i$
-  // Intended destination at iteration $t$ for pedestrian $i$
-  Vector2d r[n_iter][n_p];
+  int n_p = atoi(argv[1]);
+  int n_iter = atoi(argv[2]);
 
-  // $\vec{e}_i$
-  // Desired direction to the next way point at iteration $t$ for pedestrian $i$
-  Vector2d e[n_iter][n_p];
-
-  // $v_i^{max}$
-  // Maximum allowed speed for pedestrian $i$
-  double v_max[n_p];
-
-  // $v_i^{0}$
-  // Desired speed for pedestrian $i$
-  double v_0[n_p];
-
-  // $\vec{F}_i$
-  // Total social force for pedestrian $i$
-  Vector2d F[n_p][n_p];
-
-  // $\vec{r}_0$
-  // Desired destination of pedestrian $n_p$
-  Vector2d r_0[n_p];
+  Pedestrian *pedestrians = init_pedestrians(n_p);
 
   for (int t = 0; t < n_iter; t++) {
+
     for (int i = 0; i < n_p; i++) {
-      for (int itr = 0; itr < n_p; itr++) {
-        F[i][itr].reset();
-      }
-      compute_acceleration_term(F[i]);
-      compute_repulsive_effects_from_pedestrians(F[i]);
-      compute_repulsive_effects_from_borders(F[i]);
 
-      // TODO: Update $\vec{w}_i$
+      Pedestrian &p = pedestrians[i];
 
-      // TODO: Update $\vec{v}_i^{t+1}$
+      p.F_i.reset();
 
-      // TODO: pdate $\vec{r}_i^{t+1}$
+      //
+      // $\vec{F}_\alpha(\vec{v}_\alpha, v^0_\alpha \vec{e}_\alpha) \vec{e}_\alpha(t) = \frac{1}{\tau_\alpha}(v^0_\alpha \vec{e}_\alpha - \vec{v}_\alpha)$
+      //
+      compute_acceleration_term(&p);
+
+      //
+      // $\sum_{\beta} \vec{F}_{\alpha\beta}(\vec{e}_{\alpha}, \vec{r}_{\alpha} - \vec{r}_{\beta})$
+      //
+      compute_repulsive_effects_from_pedestrians(pedestrians, &p, n_p);
+
+      //
+      // $\sum_{B} \vec{F}_{\alpha B}(\vec{e}_{\alpha}, \vec{r}_{\alpha} - \vec{r}_{B})$
+      //
+      compute_repulsive_effects_from_borders(B, &p);
+
+      //
+      // $\vec{w}_i = \vec{v}_i + \vec{F}_idt$
+      //
+      p.w_alpha = p.curr_vel + p.F_i * delta_t;
+
+      //
+      // $\vec{v}_i^{t+1} = \vec{w}_ig(\frac{v^{max}_i}{\Arrowvert \vec{w}_i \Arrowvert}) $
+      //
+      p.next_vel = p.w_alpha * g(p.v_max, p.w_alpha.norm());
+
+      //
+      // $\vec{r}_i^{t+1} += \vec{r}^t_i + v^t_idt$
+      //
+      p.curr_pos = p.curr_pos + p.curr_vel * delta_t;
+    }
+
+    for (int i = 0; i < n_p; i++) {
+      pedestrians[i].update();
     }
   }
 
diff --git a/pedestrian.hpp b/pedestrian.hpp
new file mode 100644
index 0000000..8cbef8b
--- /dev/null
+++ b/pedestrian.hpp
@@ -0,0 +1,85 @@
+#pragma once
+#include "vector2d.hpp"
+#include "random"
+
+
+struct Pedestrian {
+
+  // TODO: Update initial values
+  Pedestrian() :
+    curr_vel(),
+    curr_pos(),
+    e(),
+    v_max(1.34 * 1.3),
+    desired_v0(1.34),
+    destination(),
+    F_i(),
+    next_pos(),
+    next_vel(),
+    w_alpha()
+    {}
+
+  Pedestrian(
+    Vector2d c_v,
+    Vector2d c_p,
+    Vector2d e,
+    Vector2d d,
+    Vector2d f,
+    Vector2d n_p,
+    Vector2d n_v,
+    Vector2d w_alpha
+  ) : 
+  curr_vel(c_v), 
+  curr_pos(c_p), 
+  e(e),
+  v_max(),
+  desired_v0(),
+  destination(d), 
+  F_i(f), 
+  next_pos(n_p), 
+  next_vel(n_v), 
+  w_alpha(w_alpha)
+  {}
+
+  // $\vec{v}_{\alpha}(t)$
+  Vector2d curr_vel;
+
+  // $\vec{r}_\alpha(t)$
+  Vector2d curr_pos;
+
+  // $\vec{e}_{\alpha}(t)$
+  Vector2d e;
+
+  // $v_{\alpha}^{max} = 1.3 v^{0}_{\alpha}$
+  double v_max;
+
+  // $v_\alpha^0$
+  double desired_v0;
+
+  // # =============================================================
+
+  // $\vec{r}^0_\alpha$
+  Vector2d destination;
+
+  // social force
+  Vector2d F_i;
+
+  // # =============================================================
+
+  // $\vec{r}_\alpha(t+1)$
+  Vector2d next_pos;
+
+  // $\vec{v}_{\alpha}(t + 1)$
+  Vector2d next_vel;
+
+  // $\vec{w}_{\alpha}$
+  Vector2d w_alpha;
+
+  // # =============================================================
+
+  void update() {
+    curr_pos = next_pos;
+    curr_vel = next_vel;
+    e = (destination - curr_pos) / (destination - curr_pos).norm();
+  }
+};
diff --git a/tsc_x86.h b/tsc_x86.h
new file mode 100644
index 0000000..4e4baf4
--- /dev/null
+++ b/tsc_x86.h
@@ -0,0 +1,94 @@
+/* ==================== GNU C and possibly other UNIX compilers ===================== */
+	#ifndef _WIN32
+
+	#if defined(__GNUC__) || defined(__linux__)
+		#define VOLATILE __volatile__
+		#define ASM __asm__
+	#else
+		/* if we're neither compiling with gcc or under linux, we can hope
+		 * the following lines work, they probably won't */
+		#define ASM asm
+		#define VOLATILE 
+	#endif
+
+	#define myInt64 unsigned long long
+	#define INT32 unsigned int
+
+/* ======================== WIN32 ======================= */
+#else
+
+	#define myInt64 signed __int64
+	#define INT32 unsigned __int32
+
+#endif
+
+/* This is the RDTSC timer.
+ * RDTSC is an instruction on several Intel and compatible CPUs that Reads the
+ * Time Stamp Counter. The Intel manuals contain more information.
+ */
+
+
+#define COUNTER_LO(a) ((a).int32.lo)
+#define COUNTER_HI(a) ((a).int32.hi)
+#define COUNTER_VAL(a) ((a).int64)
+
+#define COUNTER(a) \
+	((unsigned long long)COUNTER_VAL(a))
+
+#define COUNTER_DIFF(a,b) \
+	(COUNTER(a)-COUNTER(b))
+
+/* ==================== GNU C and possibly other UNIX compilers ===================== */
+#ifndef _WIN32
+
+	typedef union
+	{       myInt64 int64;
+		    struct {INT32 lo, hi;} int32;
+	} tsc_counter;
+
+  #define RDTSC(cpu_c) \
+	  ASM VOLATILE ("rdtsc" : "=a" ((cpu_c).int32.lo), "=d"((cpu_c).int32.hi))
+	#define CPUID() \
+		ASM VOLATILE ("cpuid" : : "a" (0) : "bx", "cx", "dx" )
+
+/* ======================== WIN32 ======================= */
+#else
+
+	typedef union
+	{       myInt64 int64;
+			struct {INT32 lo, hi;} int32;
+	} tsc_counter;
+
+	#define RDTSC(cpu_c)   \
+	{       __asm rdtsc    \
+			__asm mov (cpu_c).int32.lo,eax  \
+			__asm mov (cpu_c).int32.hi,edx  \
+	}
+
+	#define CPUID() \
+	{ \
+		__asm mov eax, 0 \
+		__asm cpuid \
+	}
+
+#endif
+
+
+static void init_tsc() {
+	; // no need to initialize anything for x86
+}
+
+static myInt64 start_tsc(void) {
+    tsc_counter start;
+    CPUID();
+    RDTSC(start);
+    return COUNTER_VAL(start);
+}
+
+static myInt64 stop_tsc(myInt64 start) {
+	tsc_counter end;
+	RDTSC(end);
+	CPUID();
+	return COUNTER_VAL(end) - start;
+}
+
diff --git a/vector2d.hpp b/vector2d.hpp
new file mode 100644
index 0000000..b4eef41
--- /dev/null
+++ b/vector2d.hpp
@@ -0,0 +1,24 @@
+#pragma once
+#include <math.h>
+
+struct Vector2d {
+  double x, y;
+  Vector2d(double a, double b) : x(a), y(b) {}
+  Vector2d() : x(.0), y(.0) {}
+  Vector2d operator+(Vector2d v) const { return Vector2d(v.x + x, v.y + y); }
+  Vector2d operator-(Vector2d v) const { return Vector2d(x - v.x, y - v.y); }
+  Vector2d operator-(double a) const { return Vector2d(x - a, y - a); }
+  Vector2d operator+(double a) const { return Vector2d(x + a, y + a); }
+  Vector2d operator/(double a) const { return Vector2d(x / a, y / a); }
+  Vector2d operator*(double a) const { return Vector2d(x * a, y * a); }
+  Vector2d operator+=(const Vector2d &v) {
+    *this = *this + v;
+    return *this;
+  }
+  double norm() { return sqrt(x * x + y * y); }
+  double dot(Vector2d v) { return x * v.x + y * v.y; }
+  void reset() {
+    x = 0;
+    y = 0;
+  }
+};

From aa1daf9149f9a9c222c23582b44aaf3583842f0d Mon Sep 17 00:00:00 2001
From: AKallala <ahmed.kallala@hotmail.fr>
Date: Thu, 23 Apr 2026 20:14:24 +0200
Subject: [PATCH 2/4] Update board.hpp, forces.hpp, forces.cpp, main.cpp,
 pedestrian.hpp: correct some bugs in implementation

---
 board.hpp      | 38 ++++++++++++++++++--
 forces.cpp     | 96 +++++++++++++-------------------------------------
 forces.hpp     | 23 +++---------
 main.cpp       | 73 ++++++++++++++++----------------------
 pedestrian.hpp | 78 ++++------------------------------------
 5 files changed, 102 insertions(+), 206 deletions(-)

diff --git a/board.hpp b/board.hpp
index 6ee78b4..e76b5ea 100644
--- a/board.hpp
+++ b/board.hpp
@@ -1,9 +1,41 @@
 #pragma once
 #include "vector2d.hpp"
 
+struct Obstacle {
+  Vector2d start;
+  Vector2d end;
+
+  Obstacle() : start(0, 0), end(0, 0) {}
+  Obstacle(Vector2d s, Vector2d e) : start(s), end(e) {}
+  // find the point of the obstacle that is nearest to p
+  Vector2d find_nearest_obstacle_point(Vector2d p) {
+    Vector2d obstacle_v = end - start;
+    double projection = (p - start).dot(obstacle_v) / obstacle_v.dot(obstacle_v);
+    if (projection < 0.0)
+      projection = 0.0;
+    if (projection > 1.0)
+      projection = 1.0;
+    return start + obstacle_v * projection;
+  }
+};
+
 struct Board {
   double length, width;
-  Vector2d *borders; // array containing the position of each obstacle
-  int n_borders;     // number of obstacles
-  Board(double l, double w, int n, Vector2d *border) : length(l), width(w), n_borders(n), borders(border) {}
+  Obstacle *obstacles; // array of obstacles (represented as lines) that are present on the board
+  int n_obstacles;     // number of obstacles
+
+  Board(double l, double w, int n, Obstacle *o) : length(l), width(w), n_obstacles(n + 4) {
+    obstacles = new Obstacle[n + 4];
+    for (int i = 0; i < n; i++) {
+      obstacles[i] = o[i];
+    }
+
+    // borders of the board: bottom, right, top, left
+    obstacles[n] = Obstacle(Vector2d(0, 0), Vector2d(l, 0));
+    obstacles[n + 1] = Obstacle(Vector2d(l, 0), Vector2d(l, w));
+    obstacles[n + 2] = Obstacle(Vector2d(l, w), Vector2d(0, w));
+    obstacles[n + 3] = Obstacle(Vector2d(0, w), Vector2d(0, 0));
+  }
+
+  ~Board() { delete[] obstacles; }
 };
diff --git a/forces.cpp b/forces.cpp
index b48d0d0..24dfa5f 100644
--- a/forces.cpp
+++ b/forces.cpp
@@ -1,35 +1,26 @@
 #include "forces.hpp"
 #include <math.h>
 
-// # Done
 double w(Vector2d e, Vector2d f) {
   if (e.dot(f) >= f.norm() * cos_phi)
     return 1.0;
-  return c;
+  else
+    return c;
+}
+
+double g(double v_max_alpha, double w_alpha_norm) {
+  if (w_alpha_norm <= v_max_alpha) {
+    return 1;
+  }
+  return v_max_alpha / w_alpha_norm;
 }
 
-// # Done
-//
-// $\vec{F}_\alpha(\vec{v}_\alpha, v^0_\alpha \vec{e}_\alpha) \vec{e}_\alpha(t) = \frac{1}{\tau_\alpha}(v^0_\alpha \vec{e}_\alpha - \vec{v}_\alpha)$
-//
 void compute_acceleration_term(Pedestrian *p) {
-
-  // $v_{\alpha}^{0}\vec{e}_{\alpha}$
   Vector2d desired_velocity = p->e * p->desired_v0;
-
-  // $\vec{v}_{\alpha}(t)$
   Vector2d actual_velocity = p->curr_vel;
-
-  double tau_alpha_inv = 1 / tau_alpha;
-
-  p->F_i += (desired_velocity - actual_velocity) * tau_alpha_inv;
+  p->f_i += (desired_velocity - actual_velocity) / tau_alpha;
 }
 
-// # Done
-//
-// $\sum_{\beta} \vec{F}_{\alpha\beta}(\vec{e}_{\alpha}, \vec{r}_{\alpha} - \vec{r}_{\beta})$
-//
-
 void compute_repulsive_effects_from_pedestrians(Pedestrian *pedestrians, Pedestrian *p, int N) {
 
   for (int i = 0; i < N; i++) {
@@ -43,78 +34,41 @@ void compute_repulsive_effects_from_pedestrians(Pedestrian *pedestrians, Pedestr
     //   continue;
     // }
 
-    // $\vec{r}_{\alpha\beta}$
     Vector2d r_ab = p->curr_pos - pedestrians[i].curr_pos;
 
-    // $\Arrowvert \vec{r}_{\alpha \beta} \Arrowvert$
     double r_ab_norm = r_ab.norm();
 
-    // $\vec{e}_{\beta}$
-    Vector2d e_beta = pedestrians[i].e;
+    Vector2d e_b = pedestrians[i].e;
 
-    // $v_\beta \Delta t$
-    double v_beta_delta_t = pedestrians[i].desired_v0 * delta_t;
+    double s_b = pedestrians[i].desired_v0 * delta_t;
 
-    // $\vec{r}_{\alpha\beta} - \vec{v}_{\beta}\varDelta_{t}\vec{e}_{\beta}$
-    Vector2d r_ab_minus_v_beta_delta_t_e_beta = r_ab - (e_beta * v_beta_delta_t);
+    Vector2d r_ab2 = r_ab - (e_b * s_b);
 
-    // $\Arrowvert \vec{r}_{\alpha \beta} - v_\beta \Delta t \vec{e}_\beta \Arrowvert$
-    double r_ab_minus_v_beta_delta_t_e_beta_norm = r_ab_minus_v_beta_delta_t_e_beta.norm();
+    double r_ab2_norm = r_ab2.norm();
 
-    // (4):
-    //
-    // $2b = \sqrt{(\Arrowvert \vec{r}_{\alpha \beta} \Arrowvert + \Arrowvert \vec{r}_{\alpha \beta} - v_\beta \Delta t \vec{e}_\beta \Arrowvert)^2 - (v_\beta \Delta t)^2}$
-    //
+    double b = sqrt(pow(r_ab_norm + r_ab2_norm, 2) - pow(s_b, 2)) / 2;
 
-    double b = sqrt((r_ab_norm + r_ab_minus_v_beta_delta_t_e_beta_norm) * (r_ab_norm + r_ab_minus_v_beta_delta_t_e_beta_norm) - (v_beta_delta_t) * (v_beta_delta_t)) / 2;
+    Vector2d b_grad = (r_ab / r_ab_norm + r_ab2 / r_ab2_norm) * (r_ab_norm + r_ab2_norm) / (4 * b);
 
-    // (7):
-    //
-    // $\grad_{\vec{r}_{\alpha \beta}}b = \frac{(\Arrowvert \vec{r}_{\alpha \beta} \Arrowvert + \Arrowvert \vec{r}_{\alpha \beta} - v_\beta \Delta t \vec{e}_\beta \Arrowvert) (\frac{\vec{r}_{\alpha \beta}}{\Arrowvert \vec{r}_{\alpha \beta} \Arrowvert} + \frac{\vec{r}_{\alpha \beta} - v_\beta \Delta t \vec{e}_\beta}{\Arrowvert \vec{r}_{\alpha \beta} - v_\beta \Delta t \vec{e}_\beta \Arrowvert})}{4b}$
-    //
-    //
-    Vector2d delta_r_alpha_beta_b = (((r_ab / r_ab_norm) + (r_ab_minus_v_beta_delta_t_e_beta / r_ab_minus_v_beta_delta_t_e_beta_norm)) * (r_ab_norm + r_ab_minus_v_beta_delta_t_e_beta_norm)) / (4 * b);
+    Vector2d f_ped = b_grad * ((V0_AB / SIGMA) * (exp(-b / SIGMA)));
 
-    // (5):
-    //
-    // $\vec{f}_{\alpha \beta}(\vec{r}_{\alpha \beta}) = \frac{V^0_{\alpha \beta}}{\sigma}e^{-b / \sigma} \grad_{\vec{r}_{\alpha \beta}}b$
-    //
-    //
-    Vector2d f_alpha_beta_r_alpha_beta = delta_r_alpha_beta_b * ((V0_AB / SIGMA) * (exp(-b / SIGMA)));
-
-    // (11):
-    //
-    // $\vec{F}_{\alpha\beta}(\vec{e}_{\alpha}, \vec{r}_{\alpha} - \vec{r}_{\beta}) = w(\vec{e}_{\alpha}, -\vec{f}_{\alpha\beta})\vec{f}_{\alpha\beta}(\vec{r}_{\alpha} - \vec{r}_{\beta})$
-    //
-    // Add repulsive effects from other pedestrians to current pedestrian's social force
-    p->F_i += f_alpha_beta_r_alpha_beta * w(p->e, f_alpha_beta_r_alpha_beta * -1);
+    p->f_i += f_ped * w(p->e, f_ped * -1);
   }
 }
 
-// # Done
-void compute_repulsive_effects_from_borders(Board &B, Pedestrian *p) {
+void compute_repulsive_effects_from_borders(Board &board, Pedestrian *p) {
 
-  Vector2d *borders = B.borders;
-  int n_borders = B.n_borders;
+  Obstacle *obstacles = board.obstacles;
+  int n_borders = board.n_obstacles;
 
   for (int i = 0; i < n_borders; i++) {
 
-    Vector2d border = borders[i];
+    Obstacle obstacle = obstacles[i];
 
-    // $\vec{r}_{\alpha B}$
-    Vector2d r_alpha_B = p->curr_pos - border;
+    Vector2d r_aB = p->curr_pos - obstacle.find_nearest_obstacle_point(p->curr_pos);
 
-    //
-    // $\vec{F}_{\alpha B}(\vec{r}_{\alpha B}) = \frac{U^0_{\alpha B}}{R} e^{- \Arrowvert \vec{r}_{\alpha B} \Arrowvert / R} \frac{\vec{r}_{\alpha B}}{\Arrowvert \vec{r}_{\alpha B} \Arrowvert}$
-    //
+    Vector2d f_obst = (r_aB / r_aB.norm()) * (U0_AB / R) * std::exp(-r_aB.norm() / R);
 
-    Vector2d F_alpha_B = (r_alpha_B / r_alpha_B.norm()) * (U0_AB / R) * std::exp(-r_alpha_B.norm() / R);
-
-    // (12):
-    // 
-    // $\vec{F}_{\alpha B}(\vec{e}_{\alpha}, \vec{r}_{\alpha} - \vec{r}_{ B}) = w(\vec{e}_{\alpha}, -\vec{F}_{\alpha B})\vec{F}_{\alpha B}(\vec{r}_{\alpha} - \vec{r}_{ B})$
-    // 
-
-    p->F_i += F_alpha_B * w(p->e, F_alpha_B * (-1));
+    p->f_i += f_obst;
   }
 }
diff --git a/forces.hpp b/forces.hpp
index 27cc042..3d2bd4a 100644
--- a/forces.hpp
+++ b/forces.hpp
@@ -3,46 +3,33 @@
 #include "pedestrian.hpp"
 #include <cmath>
 
-// $\tau_{\alpha}$
-// https://arxiv.org/pdf/cond-mat/9805244, page 8
 const double tau_alpha = 0.5;
 
-// $V^0_{\alpha \beta}$
-// https://arxiv.org/pdf/cond-mat/9805244, page 8
 const double V0_AB = 2.1;
 
-// $\sigma$
-// https://arxiv.org/pdf/cond-mat/9805244, page 8
 const double SIGMA = 0.3;
 
-// $U^0_{\alpha B}$
-// https://arxiv.org/pdf/cond-mat/9805244, page 8
 const double U0_AB = 10.0;
 
-// $R$
-// https://arxiv.org/pdf/cond-mat/9805244, page 8
 const double R = 0.2;
 
-// $c$
-// https://arxiv.org/pdf/cond-mat/9805244, page 8
 const double c = 0.5;
 
-// $\varphi$
-// https://arxiv.org/pdf/cond-mat/9805244, page 8
-const double phi = 100.0;
+const double phi = 100.0 / 180.0 * M_PI;
 
 const double cos_phi = cos(phi);
 
-// $\varDelta_{t}$
-// step size = 0.2 seconds
-// https://arxiv.org/pdf/cond-mat/9805244, page 8
 const double delta_t = 2;
 
+const double dt = 0.01;
+
 // # Optional (forces.cpp: compute_repulsive_effects_from_pedestrians)
 // const double DISTANCE = 2.0;
 
 double w(Vector2d e, Vector2d f);
 
+double g(double v_max_alpha, double w_alpha_norm);
+
 void compute_acceleration_term(Pedestrian *p);
 
 void compute_repulsive_effects_from_pedestrians(Pedestrian *P, Pedestrian *p, int N);
diff --git a/main.cpp b/main.cpp
index 2e6035b..10ee86e 100644
--- a/main.cpp
+++ b/main.cpp
@@ -4,12 +4,8 @@
 #include "pedestrian.hpp"
 #include "vector2d.hpp"
 
-double g(double v_max_alpha, double w_alpha_norm) {
-  if (w_alpha_norm <= v_max_alpha) {
-    return 1;
-  }
-  return v_max_alpha / w_alpha_norm;
-}
+#define BOARD_WIDTH 10.0
+#define BOARD_LENGTH 50.0
 
 using namespace std;
 
@@ -23,67 +19,58 @@ using namespace std;
 
 Pedestrian *init_pedestrians(int n_p) {
   Pedestrian *P = new Pedestrian[n_p];
-  for (int i = 0; i < n_p; i++) {
-    P[i] = Pedestrian();
+  std::random_device rd;                                     // use for truly random simulation
+  std::mt19937 gen(rd());                                    // use rd instead of 42 as seed for real randomness
+  std::normal_distribution<double> velocity_gen(1.34, 0.26); // 1.34 and 0.26 are the mean and stdrd deviation used in paper
+  std::uniform_real_distribution<double> x_gen(2, BOARD_LENGTH - 2);
+  std::uniform_real_distribution<double> y_gen(2, BOARD_WIDTH - 2);
+  for (int i = 0; i < n_p / 2; i++) {
+    Vector2d start_pos = Vector2d(1, y_gen(gen));
+    Vector2d destination = Vector2d(BOARD_LENGTH - 1, y_gen(gen));
+    double desired_v0 = velocity_gen(gen);
+    double v_max = 1.3 * desired_v0;
+    P[i] = Pedestrian(WHITE, (destination - start_pos) / (destination - start_pos).norm() * desired_v0, start_pos, (destination - start_pos) / (destination - start_pos).norm(), v_max, desired_v0, destination, Vector2d());
+  }
+
+  for (int i = n_p / 2; i < n_p; i++) {
+    Vector2d start_pos = Vector2d(BOARD_LENGTH - 1, y_gen(gen));
+    Vector2d destination = Vector2d(1, y_gen(gen));
+    double desired_v0 = velocity_gen(gen);
+    double v_max = 1.3 * desired_v0;
+    P[i] = Pedestrian(BLACK, (destination - start_pos) / (destination - start_pos).norm() * desired_v0, start_pos, (destination - start_pos) / (destination - start_pos).norm(), v_max, desired_v0, destination, Vector2d(0, 0));
   }
   return P;
 }
 
-Board init_board(int width, int length) {
-  Vector2d obs[] = {Vector2d(2.0, 1.0), Vector2d(4.0, 1.0), Vector2d(6.0, 2.0), Vector2d(6.0, 4.0)};
-  return Board(width, length, 4, obs);
-}
+int main(int argc, const char *argv[]) {
 
-int main(int argc, const char* argv[]) {
-
-  Board B = init_board(10, 15);
+  Obstacle obs[] = {};
+  Board board = Board(BOARD_LENGTH, BOARD_WIDTH, 0, obs);
 
   int n_p = atoi(argv[1]);
   int n_iter = atoi(argv[2]);
-
   Pedestrian *pedestrians = init_pedestrians(n_p);
-
   for (int t = 0; t < n_iter; t++) {
 
     for (int i = 0; i < n_p; i++) {
 
       Pedestrian &p = pedestrians[i];
 
-      p.F_i.reset();
+      p.f_i.reset();
 
-      //
-      // $\vec{F}_\alpha(\vec{v}_\alpha, v^0_\alpha \vec{e}_\alpha) \vec{e}_\alpha(t) = \frac{1}{\tau_\alpha}(v^0_\alpha \vec{e}_\alpha - \vec{v}_\alpha)$
-      //
       compute_acceleration_term(&p);
 
-      //
-      // $\sum_{\beta} \vec{F}_{\alpha\beta}(\vec{e}_{\alpha}, \vec{r}_{\alpha} - \vec{r}_{\beta})$
-      //
       compute_repulsive_effects_from_pedestrians(pedestrians, &p, n_p);
 
-      //
-      // $\sum_{B} \vec{F}_{\alpha B}(\vec{e}_{\alpha}, \vec{r}_{\alpha} - \vec{r}_{B})$
-      //
-      compute_repulsive_effects_from_borders(B, &p);
+      compute_repulsive_effects_from_borders(board, &p);
 
-      //
-      // $\vec{w}_i = \vec{v}_i + \vec{F}_idt$
-      //
-      p.w_alpha = p.curr_vel + p.F_i * delta_t;
+      Vector2d w_alpha = p.curr_vel + p.f_i * dt;
 
-      //
-      // $\vec{v}_i^{t+1} = \vec{w}_ig(\frac{v^{max}_i}{\Arrowvert \vec{w}_i \Arrowvert}) $
-      //
-      p.next_vel = p.w_alpha * g(p.v_max, p.w_alpha.norm());
+      p.curr_vel = w_alpha * g(p.v_max, w_alpha.norm());
 
-      //
-      // $\vec{r}_i^{t+1} += \vec{r}^t_i + v^t_idt$
-      //
-      p.curr_pos = p.curr_pos + p.curr_vel * delta_t;
-    }
+      p.curr_pos = p.curr_pos + p.curr_vel * dt;
 
-    for (int i = 0; i < n_p; i++) {
-      pedestrians[i].update();
+      p.e = (p.destination - p.curr_pos) / (p.destination - p.curr_pos).norm();
     }
   }
 
diff --git a/pedestrian.hpp b/pedestrian.hpp
index 8cbef8b..54b3abe 100644
--- a/pedestrian.hpp
+++ b/pedestrian.hpp
@@ -1,85 +1,21 @@
 #pragma once
-#include "vector2d.hpp"
 #include "random"
+#include "vector2d.hpp"
 
+// For visual simulation
+enum Color { BLACK, WHITE };
 
 struct Pedestrian {
-
-  // TODO: Update initial values
-  Pedestrian() :
-    curr_vel(),
-    curr_pos(),
-    e(),
-    v_max(1.34 * 1.3),
-    desired_v0(1.34),
-    destination(),
-    F_i(),
-    next_pos(),
-    next_vel(),
-    w_alpha()
-    {}
-
-  Pedestrian(
-    Vector2d c_v,
-    Vector2d c_p,
-    Vector2d e,
-    Vector2d d,
-    Vector2d f,
-    Vector2d n_p,
-    Vector2d n_v,
-    Vector2d w_alpha
-  ) : 
-  curr_vel(c_v), 
-  curr_pos(c_p), 
-  e(e),
-  v_max(),
-  desired_v0(),
-  destination(d), 
-  F_i(f), 
-  next_pos(n_p), 
-  next_vel(n_v), 
-  w_alpha(w_alpha)
-  {}
-
-  // $\vec{v}_{\alpha}(t)$
+  Color color;
   Vector2d curr_vel;
-
-  // $\vec{r}_\alpha(t)$
   Vector2d curr_pos;
-
-  // $\vec{e}_{\alpha}(t)$
   Vector2d e;
-
-  // $v_{\alpha}^{max} = 1.3 v^{0}_{\alpha}$
   double v_max;
-
-  // $v_\alpha^0$
   double desired_v0;
-
-  // # =============================================================
-
-  // $\vec{r}^0_\alpha$
   Vector2d destination;
+  Vector2d f_i;
 
-  // social force
-  Vector2d F_i;
+  Pedestrian() : color(WHITE), curr_vel(0.0, 0.0), curr_pos(0.0, 0.0), e(0.0, 0.0), v_max(0.0), desired_v0(0.0), destination(0.0, 0.0), f_i(0.0, 0.0) {}
 
-  // # =============================================================
-
-  // $\vec{r}_\alpha(t+1)$
-  Vector2d next_pos;
-
-  // $\vec{v}_{\alpha}(t + 1)$
-  Vector2d next_vel;
-
-  // $\vec{w}_{\alpha}$
-  Vector2d w_alpha;
-
-  // # =============================================================
-
-  void update() {
-    curr_pos = next_pos;
-    curr_vel = next_vel;
-    e = (destination - curr_pos) / (destination - curr_pos).norm();
-  }
+  Pedestrian(Color clr, Vector2d c_v, Vector2d c_p, Vector2d e, double v_max, double desired_v0, Vector2d d, Vector2d f) : color(clr), curr_vel(c_v), curr_pos(c_p), e(e), v_max(v_max), desired_v0(desired_v0), destination(d), f_i(f) {}
 };

From 3d217e784060de58d1dc570cca767c59f6a87867 Mon Sep 17 00:00:00 2001
From: Nguyen Quy Anh <23906-nguyenquy@users.noreply.gitlab.inf.ethz.ch>
Date: Fri, 24 Apr 2026 16:31:42 +0200
Subject: [PATCH 3/4] Added measurements

---
 board.hpp    |  15 +++++++--
 forces.cpp   |  22 +++++++++++-
 main         | Bin 0 -> 31912 bytes
 main.cpp     |  30 +++++++++++++++++
 questions.md |   6 ++++
 tsc_x86.h    |  93 +++++++++++++++++++++++----------------------------
 vector2d.hpp |   2 ++
 7 files changed, 113 insertions(+), 55 deletions(-)
 create mode 100755 main
 create mode 100644 questions.md

diff --git a/board.hpp b/board.hpp
index e76b5ea..33da163 100644
--- a/board.hpp
+++ b/board.hpp
@@ -7,16 +7,27 @@ struct Obstacle {
 
   Obstacle() : start(0, 0), end(0, 0) {}
   Obstacle(Vector2d s, Vector2d e) : start(s), end(e) {}
-  // find the point of the obstacle that is nearest to p
+
+  // Find the point of the obstacle that is nearest to p
+  // # 15 flops
   Vector2d find_nearest_obstacle_point(Vector2d p) {
+
+    // # 2 ADDs
     Vector2d obstacle_v = end - start;
+
+    // # 9 flops =  2 ADDs, 2 MULTs, 1 ADD, 1 DIV, 2 MULTs, 1 ADD
     double projection = (p - start).dot(obstacle_v) / obstacle_v.dot(obstacle_v);
+
     if (projection < 0.0)
       projection = 0.0;
-    if (projection > 1.0)
+    else if (projection > 1.0)
       projection = 1.0;
+
+    // # 4 flops = 2 ADDs, 2 MULTs
     return start + obstacle_v * projection;
+
   }
+
 };
 
 struct Board {
diff --git a/forces.cpp b/forces.cpp
index 24dfa5f..5911909 100644
--- a/forces.cpp
+++ b/forces.cpp
@@ -1,6 +1,7 @@
 #include "forces.hpp"
 #include <math.h>
 
+// # 8 flops = 5 MULTs, 2 ADD, 1 SQRT
 double w(Vector2d e, Vector2d f) {
   if (e.dot(f) >= f.norm() * cos_phi)
     return 1.0;
@@ -8,6 +9,7 @@ double w(Vector2d e, Vector2d f) {
     return c;
 }
 
+// # 2 DIVs
 double g(double v_max_alpha, double w_alpha_norm) {
   if (w_alpha_norm <= v_max_alpha) {
     return 1;
@@ -15,12 +17,16 @@ double g(double v_max_alpha, double w_alpha_norm) {
   return v_max_alpha / w_alpha_norm;
 }
 
+// # 8 flops
 void compute_acceleration_term(Pedestrian *p) {
+  // # 2 flops
   Vector2d desired_velocity = p->e * p->desired_v0;
   Vector2d actual_velocity = p->curr_vel;
+  // # 6 flops = 4 ADDs, 2 DIVs
   p->f_i += (desired_velocity - actual_velocity) / tau_alpha;
 }
 
+// # 55(N - 1) = 55N - 55 flops
 void compute_repulsive_effects_from_pedestrians(Pedestrian *pedestrians, Pedestrian *p, int N) {
 
   for (int i = 0; i < N; i++) {
@@ -34,28 +40,39 @@ void compute_repulsive_effects_from_pedestrians(Pedestrian *pedestrians, Pedestr
     //   continue;
     // }
 
+    // # 2 ADDs
     Vector2d r_ab = p->curr_pos - pedestrians[i].curr_pos;
 
+    // # 4 flops = 1 SQRT, 2 MULTs, 1 ADD
     double r_ab_norm = r_ab.norm();
 
     Vector2d e_b = pedestrians[i].e;
 
+    // # 2 MULTs
     double s_b = pedestrians[i].desired_v0 * delta_t;
 
+    // # 4 flops = 2 ADDs, 2 MULTs
     Vector2d r_ab2 = r_ab - (e_b * s_b);
 
+    // # 4 flops = 1 SQRT, 2 MULTs, 1 ADD
     double r_ab2_norm = r_ab2.norm();
 
-    double b = sqrt(pow(r_ab_norm + r_ab2_norm, 2) - pow(s_b, 2)) / 2;
+    // # 7 flops = 1 SQRT, 3 ADDs, 2 MULTs, 1 DIV
+    double b = sqrt((r_ab_norm + r_ab2_norm) * (r_ab_norm + r_ab2_norm) - s_b * s_b) / 2;
 
+    // # 12 flops = 6 DIVs, 3 ADDs, 3 MULTs
     Vector2d b_grad = (r_ab / r_ab_norm + r_ab2 / r_ab2_norm) * (r_ab_norm + r_ab2_norm) / (4 * b);
 
+    // # 6 flops = 3 MULTs, 2 DIVs, 1 EXP
     Vector2d f_ped = b_grad * ((V0_AB / SIGMA) * (exp(-b / SIGMA)));
 
+    // # 14 flops: 9 MULTs, 4 ADDs, 1 SQRT
     p->f_i += f_ped * w(p->e, f_ped * -1);
   }
 }
 
+// # Assume that the four borders are also 4 obstacles
+// # 36 n_obstacles flops = 144 flops
 void compute_repulsive_effects_from_borders(Board &board, Pedestrian *p) {
 
   Obstacle *obstacles = board.obstacles;
@@ -65,10 +82,13 @@ void compute_repulsive_effects_from_borders(Board &board, Pedestrian *p) {
 
     Obstacle obstacle = obstacles[i];
 
+    // # 17 flops
     Vector2d r_aB = p->curr_pos - obstacle.find_nearest_obstacle_point(p->curr_pos);
 
+    // # 17 flops = 2 DIVs, 1 SQRT, 2 MULTs, 1 ADD, 2 MULTs, 1 DIV, 2 MULTs, 1 EXP, 1 SQRT, 2 MULTs, 1 ADD, 1 DIV
     Vector2d f_obst = (r_aB / r_aB.norm()) * (U0_AB / R) * std::exp(-r_aB.norm() / R);
 
+    // # 2 ADDs
     p->f_i += f_obst;
   }
 }
diff --git a/main b/main
new file mode 100755
index 0000000000000000000000000000000000000000..6df50769a8b160144d31a3d4aa10357823305fe1
GIT binary patch
literal 31912
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
WNdNR{x*Ck%@Vv&c-jBgADE(g?lkXJ(

literal 0
HcmV?d00001

diff --git a/main.cpp b/main.cpp
index 10ee86e..ffbc725 100644
--- a/main.cpp
+++ b/main.cpp
@@ -2,7 +2,9 @@
 #include "forces.hpp"
 #include "math.h"
 #include "pedestrian.hpp"
+#include "tsc_x86.h"
 #include "vector2d.hpp"
+#include <iostream>
 
 #define BOARD_WIDTH 10.0
 #define BOARD_LENGTH 50.0
@@ -50,6 +52,11 @@ int main(int argc, const char *argv[]) {
   int n_p = atoi(argv[1]);
   int n_iter = atoi(argv[2]);
   Pedestrian *pedestrians = init_pedestrians(n_p);
+
+  // # Start here or right after function signature
+  uint64_t start = start_tsc();
+
+  // # (8 + 55N - 55 + 144 + 4 + 8 + 4 + 10)*n_p*n_iter
   for (int t = 0; t < n_iter; t++) {
 
     for (int i = 0; i < n_p; i++) {
@@ -58,21 +65,44 @@ int main(int argc, const char *argv[]) {
 
       p.f_i.reset();
 
+      // # 8 flops
       compute_acceleration_term(&p);
 
+      // # 55N - 55 flops
       compute_repulsive_effects_from_pedestrians(pedestrians, &p, n_p);
 
+      // # 144 flops
       compute_repulsive_effects_from_borders(board, &p);
 
+      // # 4 flops = 2 ADDs, 2 MULTs
       Vector2d w_alpha = p.curr_vel + p.f_i * dt;
 
+      // # 8 flops = 2 MULTs, 2 DIVs, 1 SQRT, 2 MULTs, 1 ADD
       p.curr_vel = w_alpha * g(p.v_max, w_alpha.norm());
 
+      // # 4 flops = 2 ADDs, 2 MULTs
       p.curr_pos = p.curr_pos + p.curr_vel * dt;
 
+      // # 10 flops = 5 ADDs, 2 DIVs, 1 SQRT, 2 MULTs
       p.e = (p.destination - p.curr_pos) / (p.destination - p.curr_pos).norm();
     }
   }
+  int W = (8 + 55 * n_p - 55 + 144 + 4 + 8 + 4 + 10) * n_p * n_iter;
+  std::cout << "W(n): ";
+  std::cout << W;
+  std::cout << " flops\n";
+  
+  double T = stop_tsc(start);
+  std::cout << "T(n): ";
+  std::cout << T;
+  std::cout << " cycles\n";
 
+  double P = W/T;
+
+  std::cout << "P(n): ";
+  std::cout << P;
+  std::cout << " flops/cycle\n";
+
+  delete []pedestrians;
   return 0;
 }
diff --git a/questions.md b/questions.md
new file mode 100644
index 0000000..6de7008
--- /dev/null
+++ b/questions.md
@@ -0,0 +1,6 @@
+- [ ] SQRT == 1 flop? EXP == 1 flop?
+- [ ] Where to start measurements, do we include measurements?
+- [ ] Can Vector2d be reused?
+- [ ] How precise do we have to be? How do we define "correctness"?
+- [ ] Do borders count as obstacles?
+- [ ] Do we use a fixed machine, frequency scaling, etc.
diff --git a/tsc_x86.h b/tsc_x86.h
index 4e4baf4..be144a3 100644
--- a/tsc_x86.h
+++ b/tsc_x86.h
@@ -1,24 +1,24 @@
 /* ==================== GNU C and possibly other UNIX compilers ===================== */
-	#ifndef _WIN32
+#ifndef _WIN32
 
-	#if defined(__GNUC__) || defined(__linux__)
-		#define VOLATILE __volatile__
-		#define ASM __asm__
-	#else
-		/* if we're neither compiling with gcc or under linux, we can hope
-		 * the following lines work, they probably won't */
-		#define ASM asm
-		#define VOLATILE 
-	#endif
+#if defined(__GNUC__) || defined(__linux__)
+#define VOLATILE __volatile__
+#define ASM __asm__
+#else
+/* if we're neither compiling with gcc or under linux, we can hope
+ * the following lines work, they probably won't */
+#define ASM asm
+#define VOLATILE
+#endif
 
-	#define myInt64 unsigned long long
-	#define INT32 unsigned int
+#define myInt64 unsigned long long
+#define INT32 unsigned int
 
 /* ======================== WIN32 ======================= */
 #else
 
-	#define myInt64 signed __int64
-	#define INT32 unsigned __int32
+#define myInt64 signed __int64
+#define INT32 unsigned __int32
 
 #endif
 
@@ -27,68 +27,57 @@
  * Time Stamp Counter. The Intel manuals contain more information.
  */
 
-
 #define COUNTER_LO(a) ((a).int32.lo)
 #define COUNTER_HI(a) ((a).int32.hi)
 #define COUNTER_VAL(a) ((a).int64)
 
-#define COUNTER(a) \
-	((unsigned long long)COUNTER_VAL(a))
+#define COUNTER(a) ((unsigned long long)COUNTER_VAL(a))
 
-#define COUNTER_DIFF(a,b) \
-	(COUNTER(a)-COUNTER(b))
+#define COUNTER_DIFF(a, b) (COUNTER(a) - COUNTER(b))
 
 /* ==================== GNU C and possibly other UNIX compilers ===================== */
 #ifndef _WIN32
 
-	typedef union
-	{       myInt64 int64;
-		    struct {INT32 lo, hi;} int32;
-	} tsc_counter;
+typedef union {
+  myInt64 int64;
+  struct {
+    INT32 lo, hi;
+  } int32;
+} tsc_counter;
 
-  #define RDTSC(cpu_c) \
-	  ASM VOLATILE ("rdtsc" : "=a" ((cpu_c).int32.lo), "=d"((cpu_c).int32.hi))
-	#define CPUID() \
-		ASM VOLATILE ("cpuid" : : "a" (0) : "bx", "cx", "dx" )
+#define RDTSC(cpu_c) ASM VOLATILE("rdtsc" : "=a"((cpu_c).int32.lo), "=d"((cpu_c).int32.hi))
+#define CPUID() ASM VOLATILE("cpuid" : : "a"(0) : "bx", "cx", "dx")
 
 /* ======================== WIN32 ======================= */
 #else
 
-	typedef union
-	{       myInt64 int64;
-			struct {INT32 lo, hi;} int32;
-	} tsc_counter;
+typedef union {
+  myInt64 int64;
+  struct {
+    INT32 lo, hi;
+  } int32;
+} tsc_counter;
 
-	#define RDTSC(cpu_c)   \
-	{       __asm rdtsc    \
-			__asm mov (cpu_c).int32.lo,eax  \
-			__asm mov (cpu_c).int32.hi,edx  \
-	}
+#define RDTSC(cpu_c) {__asm rdtsc __asm mov(cpu_c).int32.lo, eax __asm mov(cpu_c).int32.hi, edx}
 
-	#define CPUID() \
-	{ \
-		__asm mov eax, 0 \
-		__asm cpuid \
-	}
+#define CPUID() {__asm mov eax, 0 __asm cpuid}
 
 #endif
 
-
 static void init_tsc() {
-	; // no need to initialize anything for x86
+  ; // no need to initialize anything for x86
 }
 
 static myInt64 start_tsc(void) {
-    tsc_counter start;
-    CPUID();
-    RDTSC(start);
-    return COUNTER_VAL(start);
+  tsc_counter start;
+  CPUID();
+  RDTSC(start);
+  return COUNTER_VAL(start);
 }
 
 static myInt64 stop_tsc(myInt64 start) {
-	tsc_counter end;
-	RDTSC(end);
-	CPUID();
-	return COUNTER_VAL(end) - start;
+  tsc_counter end;
+  RDTSC(end);
+  CPUID();
+  return COUNTER_VAL(end) - start;
 }
-
diff --git a/vector2d.hpp b/vector2d.hpp
index b4eef41..b9bf1f0 100644
--- a/vector2d.hpp
+++ b/vector2d.hpp
@@ -15,7 +15,9 @@ struct Vector2d {
     *this = *this + v;
     return *this;
   }
+  // # 4 flops = 1 SQRT, 2 MULTs, 1 ADD
   double norm() { return sqrt(x * x + y * y); }
+  // # 3 flops = 2 MULTs, 1 ADD
   double dot(Vector2d v) { return x * v.x + y * v.y; }
   void reset() {
     x = 0;

From 49e96e85a1a71e110f3cf8a7e7b18a05d82597af Mon Sep 17 00:00:00 2001
From: lbaumberger <lbaumberger@student.ethz.ch>
Date: Sat, 25 Apr 2026 20:57:50 +0200
Subject: [PATCH 4/4] created two passes Pass1: compute all forces Pass2:
 integrate the forces and do the updates

If we dont separate it, we will have some inter pedestrian forces calculated on a mix of new and updated   values
---
 main.cpp | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/main.cpp b/main.cpp
index ffbc725..6e00475 100644
--- a/main.cpp
+++ b/main.cpp
@@ -58,7 +58,7 @@ int main(int argc, const char *argv[]) {
 
   // # (8 + 55N - 55 + 144 + 4 + 8 + 4 + 10)*n_p*n_iter
   for (int t = 0; t < n_iter; t++) {
-
+    // Pass1: conmpute all forces from the current state
     for (int i = 0; i < n_p; i++) {
 
       Pedestrian &p = pedestrians[i];
@@ -73,7 +73,10 @@ int main(int argc, const char *argv[]) {
 
       // # 144 flops
       compute_repulsive_effects_from_borders(board, &p);
-
+    }
+    // Pass2: integrate the forces and update the current state
+    for (int i = 0; i < n_p; i++) {
+      Pedestrian &p = pedestrians[i];
       // # 4 flops = 2 ADDs, 2 MULTs
       Vector2d w_alpha = p.curr_vel + p.f_i * dt;
 
@@ -91,18 +94,18 @@ int main(int argc, const char *argv[]) {
   std::cout << "W(n): ";
   std::cout << W;
   std::cout << " flops\n";
-  
+
   double T = stop_tsc(start);
   std::cout << "T(n): ";
   std::cout << T;
   std::cout << " cycles\n";
 
-  double P = W/T;
+  double P = W / T;
 
   std::cout << "P(n): ";
   std::cout << P;
   std::cout << " flops/cycle\n";
 
-  delete []pedestrians;
+  delete[] pedestrians;
   return 0;
 }