/**
* Returns the angle theta such that <code>(x == cos(theta)) && (y == sin(theta))</code>.
*
* @param y the y value.
* @param x the x value.
* @return the angle theta in radians.
*/
public static double atan2(double y, double x) {
final double epsilon = 1E-128;
if (MathLib.abs(x) > epsilon) {
double temp = MathLib.atan(MathLib.abs(y) / MathLib.abs(x));
if (x < 0.0) temp = PI - temp;
if (y < 0.0) temp = TWO_PI - temp;
return temp;
} else if (y > epsilon) return HALF_PI;
else if (y < -epsilon) return 3 * HALF_PI;
else return 0.0;
}
/**
* Returns a pseudo random <code>int</code> value in the range <code>[min, max]</code> (fast and
* thread-safe without synchronization).
*
* @param min the minimum value inclusive.
* @param max the maximum value exclusive.
* @return a pseudo random number in the range <code>[min, max]</code>.
*/
public static int random(int min, int max) {
int next = RANDOM.nextInt();
if ((next >= min) && (next <= max)) return next;
next += Integer.MIN_VALUE;
if ((next >= min) && (next <= max)) return next;
// We should not have interval overflow as the interval has to be less
// or equal to Integer.MAX_VALUE (otherwise we would have exited before).
final int interval = 1 + max - min; // Positive.
if (interval <= 0) throw new Error("Interval [" + min + ".." + max + "] error"); // In case.
return MathLib.abs(next % interval) + min;
}
/**
* Returns a pseudo random <code>long</code> value in the range <code>[min, max]</code> (fast and
* thread-safe without synchronization).
*
* @param min the minimum value inclusive.
* @param max the maximum value inclusive.
* @return a pseudo random number in the range <code>[min, max]</code>.
*/
public static long random(long min, long max) {
long next = RANDOM.nextLong();
if ((next >= min) && (next <= max)) return next;
next += Long.MIN_VALUE;
if ((next >= min) && (next <= max)) return next;
// We should not have interval overflow as the interval has to be less
// or equal to Long.MAX_VALUE (otherwise we would have exited before).
final long interval = 1L + max - min; // Positive.
if (interval <= 0) throw new Error("Interval error"); // Sanity check.
return MathLib.abs(next % interval) + min;
}
static double _atan(double x) {
double w, s1, s2, z;
int ix, hx, id;
long xBits = Double.doubleToLongBits(x);
int __HIx = (int) (xBits >> 32);
int __LOx = (int) xBits;
hx = __HIx;
ix = hx & 0x7fffffff;
if (ix >= 0x44100000) { // if |x| >= 2^66
if (ix > 0x7ff00000 || (ix == 0x7ff00000 && (__LOx != 0))) return x + x; // NaN
if (hx > 0) return atanhi[3] + atanlo[3];
else return -atanhi[3] - atanlo[3];
}
if (ix < 0x3fdc0000) { // |x| < 0.4375
if (ix < 0x3e200000) // |x| < 2^-29
if (huge + x > one) return x;
id = -1;
} else {
x = MathLib.abs(x);
if (ix < 0x3ff30000) // |x| < 1.1875
if (ix < 0x3fe60000) { // 7/16 <=|x|<11/16
id = 0;
x = (2.0 * x - one) / (2.0 + x);
} else { // 11/16<=|x|< 19/16
id = 1;
x = (x - one) / (x + one);
}
else if (ix < 0x40038000) { // |x| < 2.4375
id = 2;
x = (x - 1.5) / (one + 1.5 * x);
} else { // 2.4375 <= |x| < 2^66
id = 3;
x = -1.0 / x;
}
}
// end of argument reduction
z = x * x;
w = z * z;
// break sum from i=0 to 10 aT[i]z**(i+1) into odd and even poly
s1 = z * (aT[0] + w * (aT[2] + w * (aT[4] + w * (aT[6] + w * (aT[8] + w * aT[10])))));
s2 = w * (aT[1] + w * (aT[3] + w * (aT[5] + w * (aT[7] + w * aT[9]))));
if (id < 0) return x - x * (s1 + s2);
else {
z = atanhi[id] - ((x * (s1 + s2) - atanlo[id]) - x);
return (hx < 0) ? -z : z;
}
}
/**
* Returns the remainder of the division of the specified two arguments.
*
* @param x the dividend.
* @param y the divisor.
* @return <code>x - round(x / y) * y</code>
*/
public static double rem(double x, double y) {
double tmp = x / y;
if (MathLib.abs(tmp) <= Long.MAX_VALUE) return x - MathLib.round(tmp) * y;
else return NaN;
}
