Native sin/cos functions

Question

hey I was curious how much faster I could make sin/cos functions at the expense of some accuracy. I used a taylor polynomial and found that to the 3rd degree, the results of my function were accurate to about 2 decimal points. By the 5th degree, they were pretty much perfect up till past the 8th decimal, unless youre looking for numbers close to pie/2, which is where the most inaccuracy occurs (still accurate to about the 6th decimal place). I tested this against the native Math.sin function, and found that mine was about twice as fast for 3rd degree, and about 1.5 times faster for 5th degree. However, I got some very strange results when I used large numbers in the calculations, where my results were 16X faster then the native ones. Does anyone know what they use to calculate sin and cos? heres my program and results:
public class Math
     public static double PIE = 3.14159265358979323846;
     public static double sin(double x)
          if(abs(x) <= PIE)
               return x-x*x*x/6+x*x*x*x*x/120-x*x*x*x*x*x*x/5040+x*x*x*x*x*x*x*x*x/362880;
          double t = x/PIE;
          x = PIE * (t-(int)t);
               return x-x*x*x/6+x*x*x*x*x/120-x*x*x*x*x*x*x/5040+x*x*x*x*x*x*x*x*x/362880;
     public static double abs(double n)
          return n<0?-n:n;
     public static void main(String[] args)
          int trials = 10000000;
          long initTime = System.currentTimeMillis();
          long time1 = 0;
          long time2 = 0;
          for(int loop = 0; loop < trials; loop++)
               java.lang.Math.sin(PIE/trials*loop*2);
          time1 = System.currentTimeMillis()-initTime;
          initTime = System.currentTimeMillis();
          for(int loop = 0; loop < trials; loop++)
               sin(PIE/trials*loop*2);
          time2 = System.currentTimeMillis()-initTime;
          System.out.println("System runtime: "+time1+"\nMy runtime: "+time2);
}System runtime: 2015
My runtime: 1594
          for(int loop = 0; loop < trials; loop++)
               java.lang.Math.sin(loop);
          for(int loop = 0; loop < trials; loop++)
               sin(loop);
....System runtime: 16453
My runtime: 1688
I just thought that was a little strange and was curious if anyone knew what caused it?

Answer 1

     public static double PIE = 3.14159265358979323846;Math.PI isn't good enough for you?
You can always look in the src.zip at the source code.
Did you get these polynomial approximations out of Abramowitz and Stegun? If not, go find out what that is.
Or are these Taylor series approximations that you derived for yourself? I don't think this is a good idea.
How much expertise do you have in numerical analysis? Can you speak to convergence rate, roundoff, and errors in your formulation? If not, you shouldn't offer it as an alternative.
I doubt that the folks who wrote the sine and cosine used in java.lang.Math were poor programmers. It's good for you to want to understand the details, but it's naive to think that your Taylor series approximation is such a radical improvement.
%