radians

I'm basically trying to find how many degrees apart two points of a compass are. For example if a person is facing 270 and their compass is 280 there are 10 degrees between those 2 points. I'd also like a negative number if it's to the left and positive to the right, relative to the 1st heading. The problem comes when the to headings are 350 and 020 for example. These two points are 30 degrees apart but would give a result of -330. Below is an example of my code: function ConvertToRadians(_var) { return _var * (Math.PI/180); } function ConvertToDegrees(_var) { return _var * (180/Math.PI); }

Currently using VC++ 11 with SDL2, GLM, and GLEW. The issue is stemming from GLM when I attempt to do two things: Create a rotation matrix, create a perspective camera matrix (3D). The error is: "GLM: perspective function taking degrees as a parameter is deprecated" despite the fact that I am passing radians (as floats) to both functions. It says I should define something like "#define GLM_FORCE_RADIANS." Is that really necessary? Personally I use degrees for everything, but OpenGL, so having to convert back and forth (for AI movement and what not) is a pain and actually causes a spike in CPU

In my app I'm using UIBezierPath to draw an arc into a circle. I'm trying to correlate a number to radians. So let's say a user has a certain number of points, and the points are capped at 100 points. I want 100 points to be 360 degrees. I want the first 33% of the circle to be green, and then from 34% to the next 66% of the circle to be stroked in orange, and then from 67% to 100% in red. The issue I'm having here is converting percents of a circle to radians. When creating a UIBezier path, I need to provide a startAngle and endAngle, and I'm having a bit of trouble converting these points to

Is there a library function or a well-known quick efficient way in Java to normalize an angle to +/- π — e.g. when adding two angles? What I've got now (based on this answer ) is basically the code below... private static final double TWO_PI = 2 * Math.PI; double normalize(double theta) { double normalized = theta % TWO_PI; normalized = (normalized + TWO_PI) % TWO_PI; return normalized <= Math.PI ? normalized : normalized - TWO_PI; } ...but it seems a little complicated and performance-wise I'm not excited about the modulo operator. (Note that I can't guarantee theta isn't some relatively