std::atan2 allows calculating the arctangent of all four quadrants. std::atan only allows calculating from quadrants 1 and 4.

Yep, you want atan, the arc tangent. This is the inverse of tangent; same thing with sin and arc sine, cosine and arc cosine, etc. These are alternative mathematical terminology for these functions' inverses.

Notice how atan returns angles from -π/2 to π/2, by the way. That's a hint that it's an inverse function (tangent takes angles and spits out ratios, arc tangent takes ratios and spits out angles). It is also important to recognize the restricted range. You won't necessarily get back your original angle, since tangents repeat every π radians (every 180°) — tan(π) = 0, but atan(0) = 0, not π.

This is probably beating a dead horse, since the other answer explained the basic usages of $\arctan,$ $\arccos,$ and $\operatorname{atan2},$ but I don't think the other answer explained explicitly why your particular graph ended up exactly the way it did. I will focus on just that.

What you appear to be trying to do is (in effect) to plot the direction from the origin of a Cartesian plane to the point $\left(-w^2 + \frac1{C\cdot L},-\omega\cdot\frac RL\right),$ measured as an angle counterclockwise from the positive $x$-axis, for positive values of $\omega.$

Based on the results you are getting, I suppose that $C,$ $L,$ and $R$ are all positive or all negative. So when $\omega = 0,$ this point is simply $\left(\frac1{C\cdot L},0\right),$ which is a point on the positive $x$-axis and therefore has angle $0.$

As $\omega$ increases, $-w^2 + \frac1{C\cdot L}$ and $-\omega\cdot\frac RL$ both decrease. Initially the point $\left(-w^2 + \frac1{C\cdot L},-\omega\cdot\frac RL\right)$ moves downward from the $x$-axis into the fourth quadrant, but because of the $-\omega^2$ term this point starts moving left with increasing speed relative to its downward motion.

Eventually the point $\left(-w^2 + \frac1{C\cdot L},-\omega\cdot\frac RL\right)$ crosses from the fourth quadrant into the third quadrant. That is the point at which the arc tangent function "jumps" in your graph, because when $\frac yx$ is positive, $\arctan\frac yx$ always gives a first-quadrant answer, an angle between $0$ and $\frac\pi2,$ never an angle between $-\pi$ and $-\frac\pi2.$ Angles that you wanted to be reported as slightly less than $-\frac\pi2$ are reported as slightly less than $\frac\pi2$ instead.

Using $\operatorname{atan2}$ is a simple fix because when $(x,y)$ is in the third quadrant, $\operatorname{atan2}(y,x)$ gives an angle between $-\pi$ and $-\frac\pi2,$ just as you desire.

But if you want to use the older $\arctan$ function, another simple fix is to rotate the point $\left(-w^2 + \frac1{C\cdot L},-\omega\cdot\frac RL\right)$ by $\frac\pi2$ radians counterclockwise so that it goes from the first quadrant to the fourth, during which there is no "jump" in the output of $\arctan\frac yx,$ and then subtract $\frac\pi2$ to bring the angle values back to the expected interval between $-\pi$ and $0.$ You can do this by defining

$$ f(\omega) = \arctan\left(\frac{-w^2 + \frac1{C\cdot L}}{\omega\cdot \frac RL}\right) - \frac\pi2. $$

This will plot the same as your second figure. It is possible to use the old $\arctan$ function here because the angle outputs you want all lie in a single interval of width $\pi,$ just like the output of $\arctan$; you just need something like the rotation/shift described above to deal with the different positions of these equally-wide intervals on the real number line.

Edit: at first I thought this can be answered using "results must be semi-monotonic" requirement from the javadoc, but it actually can't be applied, so I re-wrote the answer.

Almost everything I can say is already covered by dimo414's answer. I just want to add: when using Math.atan2 on the same platform or even when using StrictMath.atan2 there is no formal guarantee (from the documentation) that atan2(y, x) == atan2(y * k, x * k). Sure, StrictMath's implementation actually uses y / x, so when y / x is precisely the same double value, the results will be equal (here I reasonably imply that function is deterministic), but keep it in mind.

Answering that part about int parameters: int holds 32 bits (actually, more like 31 bits plus one bit for sign) and can be represented by double type without any loss of precision, so no new problems there.

And the difference you described in the question (for non-overflowing long values) is caused by a loss of precision when converting long values to double, it has nothing to do with Math.atan2 itself, and it happens before the function is even called. double type can hold only 53 bits of mantissa, but in your case a * k requires 54 bits, so it is rounded to the nearest number a double can represent (b * k is okay though, it requires only 52 bits):

long a = 959786689;
long b = 363236985;
long k = 9675271;

System.out.println(a * k);
System.out.println((double) (a * k));
System.out.println((long) (double) (a * k));
System.out.println((long) (double) (a * k) == a * k);

System.out.println(b * k);
System.out.println((double) (b * k));
System.out.println((long) (double) (b * k));
System.out.println((long) (double) (b * k) == b * k);

Output:

9286196318267719
9.28619631826772E15
9286196318267720
false
3514416267097935
3.514416267097935E15
3514416267097935
true

And to address the example from the comment:

We have double a = 1.02551177480084, b = 1.12312341356234, k = 5;. In this case none of a, b, a * k, b * k can be represented as double without loss of precision. I'll use BigDecimal to demonstrate it, because it can show the true (not rounded) value of double:

double a = 1.02551177480084;
System.out.println("a is            " + new BigDecimal(a));
System.out.println("a * 5 is        " + new BigDecimal(a * 5));
System.out.println("a * 5 should be " + new BigDecimal(a).multiply(new BigDecimal("5")));

outputs

a is            1.0255117748008399924941613789997063577175140380859375
a * 5 is        5.12755887400420018451541182002983987331390380859375   // precision loss here
a * 5 should be 5.1275588740041999624708068949985317885875701904296875

and the difference can be clearly seen (same can be done with b instead of a).

There is a more simple test (since atan2() essentially uses a/b):

double a = 1.02551177480084, b = 1.12312341356234, k = 5;
System.out.println(a / b == (a * k) / (b * k));

outputs

false