Re: Sines and Cosines

Kenneth P. Turvey wrote:


     Okay, here's my attempt (sources below). On a 3GHz
Pentium 4 running WinXP SP2, I get

     Java 1.6.0_05:
     nums = 1000000, runs = 10, theta = 0.0, delta = 3.8785094135818516
     360 ms, final theta = -0.739085133899082
     344 ms, final theta = -0.739085133899082
     359 ms, final theta = -0.739085133899082
     359 ms, final theta = -0.739085133899082
     360 ms, final theta = -0.739085133899082
     344 ms, final theta = -0.739085133899082
     344 ms, final theta = -0.739085133899082
     359 ms, final theta = -0.739085133899082
     343 ms, final theta = -0.739085133899082
     343 ms, final theta = -0.739085133899082

     DJGPP 3.3.3 (elderly), -O3:
     nums = 1000000, runs = 10, theta = 0, delta = 3.87851
     330 ms, final theta = -0.739085
     385 ms, final theta = -0.739085
     385 ms, final theta = -0.739085
     385 ms, final theta = -0.739085
     330 ms, final theta = -0.739085
     385 ms, final theta = -0.739085
     385 ms, final theta = -0.739085
     385 ms, final theta = -0.739085
     385 ms, final theta = -0.739085
     385 ms, final theta = -0.739085

.... suggesting Java may be just a hair faster than C, but
that it's "in the noise." (Note, too, that the notions of
"time" used in the two programs are not exactly alike.) I'll
report on results from an AMD laptop later this weekend.

     Sources:

public class TrigTime {
     public static void main(String[] args) {
         int nums = 1000000;
         if (args.length > 0)
             nums = Integer.parseInt(args[0]);
         int runs = 10;
         if (args.length > 1)
             runs = Integer.parseInt(args[1]);
         double theta = 0.0;
         if (args.length > 2)
             theta = Double.parseDouble(args[2]);
         double delta = 1.23456789 * Math.PI;
         if (args.length > 3)
             delta = Double.parseDouble(args[3]);
         System.out.println("nums = " + nums + ", runs = " + runs
             + ", theta = " + theta + ", delta = " + delta);
         for (int r = 0; r < runs; ++r) {
             cleanUpYourAct();
             long t0 = System.currentTimeMillis();
             for (int n = 0; n < nums; ++n) {
                 theta = Math.sin(theta + delta);
                 theta = Math.cos(theta + delta);
             }
             long t1 = System.currentTimeMillis();
             System.out.println((t1 - t0) + " ms, final theta = "
                 + theta);
         }
     }
     /** Without this, the timings show wild variations. */
     private static void cleanUpYourAct() {
         for (int i = 0; i < 3; ++i) {
             System.gc();
             try {
                 Thread.sleep(250);
             } catch (InterruptedException ex) {
                 // big deal
             }
         }
     }
}

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#ifndef M_PI
     #define M_PI 3.14159265358979323846
#endif
int main(int argc, char *argv[])
{
     int nums = 1000000;
     int runs = 10;
     double theta = 0.0;
     double delta = 1.23456789 * M_PI;
     int r, n;
     if (argc > 1)
         nums = atoi(argv[1]); /* sloppy, I know ... */
     if (argc > 2)
         runs = atoi(argv[2]);
     if (argc > 3)
         theta = atof(argv[3]);
     if (argc > 4)
         delta = atof(argv[4]);
     printf ("nums = %d, runs = %d, theta = %g, delta = %g\n",
             nums, runs, theta, delta);
     for (r = 0; r < runs; ++r) {
         clock_t t0, t1;
         t0 = clock();
         for (n = 0; n < nums; ++n) {
             theta = sin(theta + delta);
             theta = cos(theta + delta);
         }
         t1 = clock();
         printf ("%.0f ms, final theta = %g\n",
                 (double)((t1 - t0) * 1000.0 / CLOCKS_PER_SEC), theta);
     }
     return 0;
}

--
Eric Sosman
esosman@ieee-dot-org.invalid