-1

I've got a little Problem with the Math.cos() method. I know, I have to convert the angle to Radians before using Math.cos(). But if I just do:

System.out.println(Math.cos(Math.toRadians(90));

It outputs: 6.123233995736766E-17

Math.sin() is working well.

Sathish
  • 4,403
  • 7
  • 31
  • 53
user1432679
  • 17
  • 1
  • 4

5 Answers5

9

From trigonometry:

sin x ~= x, for small values of x
sin x = cos x+pi/2

Because pi/2 can't be represented exactly in IEEE-754 Floating point, it means, that it must be off by some value x, i.e it is represented by pi/2 +- x, where x < the least significant bit in the floating point system. Which in this case is 2^-53 = 1.1102e-16.

In this particular case x ~= 6.123233995736766E-17, which is about 55% of the maximum error. So, it's a rather good result...

Aki Suihkonen
  • 19,144
  • 1
  • 36
  • 57
3

See the Javadoc. "The conversion from degrees to radians is generally inexact."

user207421
  • 305,947
  • 44
  • 307
  • 483
  • cos x-pi/2 = sin x ~= x at smaller values and unfortunately 90/180*pi - just that much off of the actual value of pi/2. – Aki Suihkonen Oct 27 '12 at 12:30
2

The value is very close to the correct result. It seems like a loss of precision in the floating point operations of transforming degrees to radians.

Dan D.
  • 32,246
  • 5
  • 63
  • 79
  • 2
    That's the expected IEEE 574 floating point behavior, I wouldn't call it an ''issue''. See Esailija's comment. – ignis Oct 27 '12 at 12:30
  • 1
    @ignis The value of Math.cos() is required to be within 1ulp of the correct result. No amount of Goldberg can explain that away. – user207421 Oct 27 '12 at 12:33
  • 1
    While I did not vote down your answer, I think the downvote comes from how you stated it. By implying this is an "issue", a loss of precision, as opposed to the expected result working with floating point arithmetic, you confuse things. –  Oct 27 '12 at 13:07
  • OK, it's not an issue, I removed the word and explained it a little bit differently. – Dan D. Oct 27 '12 at 13:11
2

Standing temporarily on a soapbox, I think people are confused about the concepts of accuracy versus precision. Is this an issue as some have said? Is it a problem? A bug? Or is it an expected behavior of floating point arithmetic?

90 degrees is a number that is representable perfectly as an integer, even though a double. But pi/2 radians is a real number that is not represented exactly, so that representation will be slightly inaccurate. The loss is in accuracy. The fact is, this is expected behavior. We should never trust the least significant bits of a result.

Next, when we compute the value of a trigonometric function, there MAY be an additional loss of accuracy. We don't get exactly the result that we know to be true in a symbolic sense. Thus sin(pi/3) may not be exactly sqrt(3)/2, but then we can't represent sqrt(3)/2 exactly anyway. All of this is expected, and is behavior that should be dealt with by good code, not trusting the LSBs of those numbers.

0

As value of PI is irrational because of that value of trigonometry function giving approximate value. For precise value in calculator use this:

public class MyClass { public static void main(String args[]) {

  double b1=Math.cos(Math.toRadians(90));
  //approximate value 
  System.out.println(b1);
  //exact value   System.out.println(String.format("%.15f",b1));
  // I recommend you to using it upto 15f for precisely value
  double b2=Math.sin(Math.toRadians(30));
  //approximate value 
  System.out.println(b2);
  //exact value
  System.out.println(String.format("%.15f",b2));
}

}

Rajiv Shah
  • 1