/*
 * Estime les temps de calcul des principaux opérateurs numériques.
 * Sylvain Pion, Octobre 1996.
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#include <float.h>
/* #include <floatingpoint.h> */

#include "../det/consts.h"

#ifndef CLOCKS_PER_SEC
#ifdef CLOCKS_PER_SECOND
#define CLOCKS_PER_SEC CLOCKS_PER_SECOND
#else
#define CLOCKS_PER_SEC 1000000	/* default: clock() rend des microsecs. */
#endif
#endif

#define do2(a) a;a
#define do4(a) do2(a);do2(a)
#define do8(a) do4(a);do4(a)
#define do16(a) do8(a);do8(a)
#define do32(a) do16(a);do16(a)
#define do64(a) do32(a);do32(a)
#define do128(a) do64(a);do64(a)
#define do256(a) do128(a);do128(a)
#define do512(a) do256(a);do256(a)
#define do1024(a) do512(a);do512(a)

/* maniere simple de repeter plusieurs fois de suite la meme operation. */
#define do_rep(a) do32(a)
#define REPNB 32

/* Nombre de boucles pour moyenner. */
#define LOOPS 100000
#define SCALE (1000000.0/CLOCKS_PER_SEC/LOOPS/REPNB)
/* durée en micro-secondes. */

#define PRINT_BEGIN \
  clo1 = (double) clock(); \
  for (i=0; i<LOOPS; i++)

#define PRINT_END \
  clo2 = (double) clock(); \
  clointer += clo2 - clo1; \
  printf("%.4f\t", (clo2-clo1)*SCALE); \
  fflush(stdout)

double clo1, clo2;
unsigned int i;

double bench_uc();
double bench_sc();
double bench_us();
double bench_ss();
double bench_ui();
double bench_si();
double bench_ul();
double bench_sl();
double bench_sll();
double bench_ull();
double bench_f();
double bench_d();
#ifdef HAVE_EXTENDED
double bench_e();
#endif
double bench_ld();


int main()
{
  volatile unsigned int uia, uib, uic;
  volatile double da, db, dc;
  double clototi, clototf;

/*
 * Caracteristiques de l'architecture.
 */

  printf("CLOCKS_PER_SEC = %d\n", CLOCKS_PER_SEC);
  printf("Les temps d'execution sont en micro-secondes:\n\n");
  printf("Taille des types:\n");
  printf("* char:\t\t%d\n",	sizeof(char));
  printf("* short:\t%d\n",	sizeof(short));
  printf("* int:\t\t%d\n",	sizeof(int));
  printf("* long int:\t%d\n",	sizeof(long int));
  printf("* long long:\t%d\n",  sizeof(long long));
  printf("* float:\t%d\n",	sizeof(float));
  printf("* double:\t%d\n",	sizeof(double));
#ifdef HAVE_EXTENDED
  printf("* extended:\t%d\n",    sizeof(extended));
#endif
  printf("* long double:\t%d\n\n",sizeof(long double));

/*
 * Temps de calcul.
 */

  clo1 = (double) clock();
  for (i=0; i<LOOPS; i++) { do_rep( ) };
  clo2 = (double) clock();
  printf("* boucle vide: \t\t%.4f\n", (clo2-clo1)*SCALE);

  clo1 = (double) clock();
  for (i=0; i<LOOPS; i++) { do_rep(uia = uib); };
  clo2 = (double) clock();
  printf("* copie d'int: \t\t%.4f\n", (clo2-clo1)*SCALE);

  clo1 = (double) clock();
  for (i=0; i<LOOPS; i++) { do_rep(da = db); };
  clo2 = (double) clock();
  printf("* copie de double: \t%.4f\n", (clo2-clo1)*SCALE);
 
/*
 * Conversions.
 */

  printf("\nConversions:\n");

  uia = 1359784;

  clo1 = (double) clock();  
  for (i=0; i<LOOPS; i++) { do_rep(da = (double) uia); };
  clo2 = (double) clock();
  printf("* us int -> double: \t%.4f\n", (clo2-clo1)*SCALE);

  clo1 = (double) clock();
  for (i=0; i<LOOPS; i++) { do_rep(uia = (unsigned int) da); };
  clo2 = (double) clock();
  printf("* double -> us int: \t%.4f\n", (clo2-clo1)*SCALE);

/*
 * Tests de vitesse selon les types.
 */

  printf("\nType\t\t#octets\t+\t-\t*\t/\t%%\tMoyenne\n\n");

  clototi = bench_uc();
  clototi += bench_sc();
  if ( (sizeof(short) != sizeof(char)) &&
       (sizeof(short) != sizeof(int)) )
    {
      bench_us();
      bench_ss();
    };
  clototi += bench_ui();
  clototi += bench_si();
  if (sizeof(long int) != sizeof(int))
    {
      bench_ul();
      bench_sl();
    };
  if (sizeof(long int) != sizeof(long long))
    {
      bench_ull();
      bench_sll();
    };
  clototf = bench_f();
  clototf += bench_d();
#ifdef HAVE_EXTENDED
  bench_e();
#endif
  if (sizeof(long double) != sizeof(double))
    {
      bench_ld();
    };

  printf("\nBench entier:\t%.4f\n", clototi*SCALE/4.0/5.0);
  printf("Bench flottant:\t%.4f\n", clototf*SCALE/2.0/5.0);
};

double bench_uc()
{
  volatile unsigned char a, b, c;
  double clointer = 0;

  a = 34;
  b = 103;

  printf("unsigned char\t%d\t", sizeof(unsigned char));

  PRINT_BEGIN { do_rep(c = a+b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a-b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a*b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a/b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a%b); }; PRINT_END;

  printf("%.4f\n", clointer*SCALE/5);
  return clointer;
};

double bench_sc()
{
  volatile signed char a, b, c;
  double clointer = 0;

  a = 34;
  b = 103;

  printf("signed char\t%d\t", sizeof(signed char));

  PRINT_BEGIN { do_rep(c = a+b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a-b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a*b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a/b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a%b); }; PRINT_END;

  printf("%.4f\n", clointer*SCALE/5);
  return clointer;
};

double bench_us()
{
  volatile unsigned short a, b, c;
  double clointer = 0;

  a = 34;
  b = 103;

  printf("unsigned short\t%d\t", sizeof(unsigned short));

  PRINT_BEGIN { do_rep(c = a+b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a-b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a*b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a/b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a%b); }; PRINT_END;

  printf("%.4f\n", clointer*SCALE/5);
  return clointer;
};

double bench_ss()
{
  volatile signed short a, b, c;
  double clointer = 0;

  a = 34;
  b = 103;

  printf("signed short\t%d\t", sizeof(signed short));

  PRINT_BEGIN { do_rep(c = a+b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a-b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a*b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a/b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a%b); }; PRINT_END;

  printf("%.4f\n", clointer*SCALE/5);
  return clointer;
};

double bench_ui()
{
  volatile unsigned int a, b, c;
  double clointer = 0;

  a = 34;
  b = 103;

  printf("unsigned int\t%d\t", sizeof(unsigned int));

  PRINT_BEGIN { do_rep(c = a+b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a-b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a*b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a/b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a%b); }; PRINT_END;

  printf("%.4f\n", clointer*SCALE/5);
  return clointer;
};

double bench_si()
{
  volatile signed int a, b, c;
  double clointer = 0;

  a = 34;
  b = 103;

  printf("signed int\t%d\t", sizeof(signed int));

  PRINT_BEGIN { do_rep(c = a+b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a-b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a*b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a/b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a%b); }; PRINT_END;

  printf("%.4f\n", clointer*SCALE/5);
  return clointer;
};

double bench_ul()
{
  volatile unsigned long a, b, c;
  double clointer = 0;

  a = 34;
  b = 103;

  printf("unsigned long\t%d\t", sizeof(unsigned long));

  PRINT_BEGIN { do_rep(c = a+b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a-b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a*b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a/b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a%b); }; PRINT_END;

  printf("%.4f\n", clointer*SCALE/5);
  return clointer;
};

double bench_sl()
{
  volatile signed long a, b, c;
  double clointer = 0;

  a = 34;
  b = 103;

  printf("signed long\t%d\t", sizeof(signed long));

  PRINT_BEGIN { do_rep(c = a+b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a-b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a*b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a/b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a%b); }; PRINT_END;

  printf("%.4f\n", clointer*SCALE/5);
  return clointer;
};

double bench_ull()
{
  volatile unsigned long long a, b, c;
  double clointer = 0;

  a = 34;
  b = 103;

  printf("us long long\t%d\t", sizeof(unsigned long long));

  PRINT_BEGIN { do_rep(c = a+b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a-b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a*b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a/b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a%b); }; PRINT_END;

  printf("%.4f\n", clointer*SCALE/5);
  return clointer;
};

double bench_sll()
{
  volatile signed long long a, b, c;
  double clointer = 0;

  a = 34;
  b = 103;

  printf("s long long\t%d\t", sizeof(signed long long));

  PRINT_BEGIN { do_rep(c = a+b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a-b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a*b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a/b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a%b); }; PRINT_END;

  printf("%.4f\n", clointer*SCALE/5);
  return clointer;
};

double bench_f()
{
  volatile float a, b, c;
  double clointer = 0;

  a = 123.3456;
  b = 2345.2134;

  printf("\nfloat\t\t%d\t", sizeof(float));

  PRINT_BEGIN { do_rep(c = a+b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a-b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a*b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a/b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = fmod(a,b)); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = remainder(a,b)); }; PRINT_END;

  printf("%.4f\n", clointer*SCALE/5);
  return clointer;
};

double bench_d()
{
  volatile double a, b, c;
  int d;
  double clointer = 0;

  a = 123.3456;
  b = 2345.2134;
// a = b = 0.0; Sur Sparc, ca fait ramer !!!

  printf("double\t\t%d\t", sizeof(double));

  PRINT_BEGIN { do_rep(c = a+b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a-b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a*b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a/b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = fmod(a,b)); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = remainder(a,b)); }; PRINT_END;
  a = 135794.0;
  b = 2468042.0;
  PRINT_BEGIN { do_rep(c = (((a/b) + CST_3_51) - CST_3_51) * b); }; PRINT_END;
  a = 0.7;
  PRINT_BEGIN { do_rep(c = (a>.5) ? a-1 : ((a<-.5) ? a+1 : a)); }; PRINT_END;
  a = -0.7;
  PRINT_BEGIN { do_rep(c = (a>.5) ? a-1 : ((a<-.5) ? a+1 : a)); }; PRINT_END;
  a = 0.2;
  PRINT_BEGIN { do_rep(c = (a>.5) ? a-1 : ((a<-.5) ? a+1 : a)); }; PRINT_END;
  PRINT_BEGIN { do_rep(d = (a>b)); }; PRINT_END;

  printf("%.4f\n", clointer*SCALE/5);
  return clointer;
};

#ifdef HAVE_EXTENDED
double bench_e()
{
  volatile extended a, b, c;
  double clointer = 0;

  a = 123.3456;
  b = 2345.2134;

  printf("extended\t\t%d\t", sizeof(extended));

  PRINT_BEGIN { do_rep(c = a+b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a-b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a*b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a/b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = fmod(a,b)); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = remainder(a,b)); }; PRINT_END;

  printf("%.4f\n", clointer*SCALE/5);
  return clointer;
};
#endif

double bench_ld()
{
  volatile long double a, b, c;
  double clointer = 0;

  a = 123.3456;
  b = 2345.2134;

  printf("long double\t%d\t", sizeof(long double));

  PRINT_BEGIN { do_rep(c = a+b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a-b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a*b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = a/b); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = fmod(a,b)); }; PRINT_END;
  PRINT_BEGIN { do_rep(c = remainder(a,b)); }; PRINT_END;

  printf("%.4f\n", clointer*SCALE/5);
  return clointer;
};