Java Strange Behavior with Sin and ToRadians

Question

I have been given the task of using java to produce a Sin table, however I seem to get some very weird results for some values of the input. I am using the below

System.out.println("| sin(" + currentPoint + ") = " + Math.sin(Math.toRadians(currentPoint)));

Where (int) currentPoint is a value in degrees (eg 90)

These are results I find weird

| sin(360) = -2.4492935982947064E-16
| sin(180) = 1.2246467991473532E-16
| sin(150) = 0.49999999999999994
| sin(120) = 0.8660254037844387

Expecting

sin(360) = 0
sin(180) = 0
sin(150) = 0.5
sin(120) = 0.866025404

Am I missing something?

Answer 1

You're dealing with floating point numbers, looking for exact answers isn't going to work for all values. Take a look at What Every Computer Scientist Should Know About Floating-Point Arithmetic. You want your tests to be equivalent to your expectations within some delta. Note that the answers you're getting are pretty close. It's expressing values in bits that's biting you.

From the link:

Squeezing infinitely many real numbers into a finite number of bits requires an approximate representation. Although there are infinitely many integers, in most programs the result of integer computations can be stored in 32 bits. In contrast, given any fixed number of bits, most calculations with real numbers will produce quantities that cannot be exactly represented using that many bits. Therefore the result of a floating-point calculation must often be rounded in order to fit back into its finite representation. This rounding error is the characteristic feature of floating-point computation.

Answer 2

As mentioned above it is not an error, just the aproximation of computer's floating point arithmetic.

To get the expected answer, as sin() & cos() are between -1, 0 , +1, try to add 1 round it to the accurancy needed and substract 1.

x = round15(Math.sin(toRad(angle))+1)-1;

where round15 is defined

public double round15(double x){
    DecimalFormat twoDForm = new DecimalFormat("0.##############E0");
    String str = twoDForm.format(x);
    return Double.valueOf(str);
}

It works for me, hope future readers like it.

Answer 3

If your code was System.out.println("| sin(" + currentPoint + ") = " + Math.sin(currentPoint)); you would expect this:

sin(360) = 0.958915723 
sin(180) = -0.801152636 
sin(150) = -0.71487643 
sin(120) = 0.580611184 

In other words, the sine of 360 radians is 0.9589, but the sine of 360 degrees is 0.

EDIT:
The reason you're seeing unexpected results is just due to lack of precision in the calculations. If you just format the results so they have fewer decimal places, the rounding will take care of it. Do something like this:

System.out.printf("| sin(%d) = %.7f\n", currentPoint, Math.sin(Math.toRadians(currentPoint)));

Then you will get results closer to what you expect.

Answer 4

Your results are correct ... for approximation try this...

    result=Math.sin(Math.toRadians(value));
    result=format(result);


    private double format(double value) {
            return (double)Math.round(value * 1000000) / 1000000; //you can change this to round up the value(for two position use 100...)
        }

Answer 5

The posters above are right. The correct values you are expecting are:

Sin(360 degrees) = 0 Sin(180 degrees) = 0 Sin(150 degrees) = .5 Sin(120 degrees) = .866

The code is returning the correct answers. They just need to be rounded. Try this:

System.out.printf("%s%.3f","| sin(" + currentPoint + ") = ", (Math.sin(Math.toRadians(currentPoint))));

You can change the .3f value to different numbers if you want to improve or reduce decimal precision.

For some reason it displays the sin of 360 to be -0.00. I am sure there is a more elegant solution, but this should work.

EDIT: Beaten by seconds. Use the code above mine, it is easier to read.

Answer 6

Also note that Math.PI, which is a double value, is not PI, but just an approximation of PI, and Math.sin(Math.PI) gives you the double value which is the closest to actual mathematical value of sin(Math.PI).

Answer 7

You must convert the angle into radians like this

Math.sin(Math.toRadians(90)) and the result must be 1

Answer 8

Below is the API description of the Math.sin method. Note the part in asterix. I would bet that the difference between your expected results and the once you get are defects of floatpoint calculation or rounding problems.

sin

public static double sin(double a)

Returns the trigonometric sine of an angle. Special cases:

    * If the argument is NaN or an infinity, then the result is NaN.
    * If the argument is zero, then the result is a zero with the

same sign as the argument.

A result must be within 1 **ulp** of the correctly rounded result. Results

must be semi-monotonic.

Parameters:
    a - an angle, in radians. 
Returns:
    the sine of the argument.