Question

I am trying to optimize the simulation function in my experiment so I can have more artificial brain-controlled agents running at a time. I profiled my code and found out that the big bottleneck in my code right now is computing the relative angle from every agent to every agent, which is O(n²), minus some small optimizations I have done. Here is the current code snippet I have for computing the angle:

[C++]
double calcAngle(double fromX, double fromY, double fromAngle, double toX, double toY)
{
    double d = 0.0;
    double Ux = 0.0, Uy = 0.0, Vx = 0.0, Vy = 0.0;

    d = sqrt( calcDistanceSquared(fromX, fromY, toX, toY) );

    Ux = (toX - fromX) / d;

    Uy = (toY - fromY) / d;

    Vx = cos(fromAngle * (cPI / 180.0));
    Vy = sin(fromAngle * (cPI / 180.0));

    return atan2(((Ux * Vy) - (Uy * Vx)), ((Ux * Vx) + (Uy * Vy))) * 180.0 / cPI;
}

I have two 2D points (x₁, y₁) and (x₂, y₂) and the facing of the “from” point (x_a). I want to compute the angle that agent x needs to turn (relative to its current facing) to face agent y.

According to the profiler, the most expensive part is the atan2. I have Googled for hours and the above solution is the best solution I could find. Does anyone know of a more efficient way to compute the angle between two points? I am willing to sacrifice a little accuracy (+/- 1-2 degrees) for speed, if that affects anything.

Answer 1

As has been mentioned in the comments, there are probably high-level approaches to reduce your computational load.

But to the question in hand, you can just use the dot-product relationship:

theta = acos ( a . b / ||a|| ||b|| )

where a and b are your vectors, . denotes “dot product” and || || denotes “vector magnitude”.

Essentially, this will replace your {sqrt, cos, sin, atan2} with {sqrt, acos}.

I would also suggest sticking to radians for all internal calculations, only converting to and from degrees for human-readable I/O.