SingleSource/Benchmarks/Stanford/Oscar.c

#include <stdio.h>
#include <stdlib.h>

#define  nil		0
#define	 false		0
#define  true		1
#define  bubblebase	1.61f
#define  dnfbase 	3.5f
#define  permbase 	1.75f
#define  queensbase 1.83f
#define  towersbase 2.39f
#define  quickbase 	1.92f
#define  intmmbase 	1.46f
#define  treebase 	2.5f
#define  mmbase 	0.0f
#define  fpmmbase 	2.92f
#define  puzzlebase	0.5f
#define  fftbase 	0.0f
#define  fpfftbase 	4.44f
    /* Towers */
#define maxcells 	 18

    /* Intmm, Mm */
#define rowsize 	 40

    /* Puzzle */
#define size	 	 511
#define classmax 	 3
#define typemax 	 12
#define d 		     8

    /* Bubble, Quick */
#define sortelements 5000
#define srtelements  500

    /* fft */
#define fftsize 	 256 
#define fftsize2 	 129  
/*
type */
    /* Perm */
#define permrange     10

   /* tree */
struct node {
	struct node *left,*right;
	int val;
};

    /* Towers */ /*
    discsizrange = 1..maxcells; */
#define    stackrange	3
/*    cellcursor = 0..maxcells; */
struct    element {
	int discsize;
	int next;
};
/*    emsgtype = packed array[1..15] of char;
*/
    /* Intmm, Mm */ /*
    index = 1 .. rowsize;
    intmatrix = array [index,index] of integer;
    realmatrix = array [index,index] of real;
*/
    /* Puzzle */ /*
    piececlass = 0..classmax;
    piecetype = 0..typemax;
    position = 0..size;
*/
    /* Bubble, Quick */ /*
    listsize = 0..sortelements;
    sortarray = array [listsize] of integer;
*/
    /* FFT */
struct    complex { float rp, ip; } ;
/*
    carray = array [1..fftsize] of complex ;
    c2array = array [1..fftsize2] of complex ;
*/

float value, fixed, floated;

    /* global */
long    seed;  /* converted to long for 16 bit WR*/

    /* Perm */
int    permarray[permrange+1];
/* converted pctr to unsigned int for 16 bit WR*/
unsigned int    pctr;

    /* tree */
struct node *tree;

    /* Towers */
int	   stack[stackrange+1];
struct element    cellspace[maxcells+1];
int    freelist,  movesdone;

    /* Intmm, Mm */

int   ima[rowsize+1][rowsize+1], imb[rowsize+1][rowsize+1], imr[rowsize+1][rowsize+1];
float rma[rowsize+1][rowsize+1], rmb[rowsize+1][rowsize+1], rmr[rowsize+1][rowsize+1];

    /* Puzzle */
int	piececount[classmax+1],	class[typemax+1], piecemax[typemax+1];
int	puzzl[size+1], p[typemax+1][size+1], n, kount;

    /* Bubble, Quick */
int sortlist[sortelements+1], biggest, littlest, top;

    /* FFT */
struct complex    z[fftsize+1], w[fftsize+1], e[fftsize2+1];
float    zr, zi;

void Initrand () {
    seed = 74755L;   /* constant to long WR*/
}

int Rand () {
    seed = (seed * 1309L + 13849L) & 65535L;  /* constants to long WR*/
    return( (int)seed );     /* typecast back to int WR*/
}


float Cos (float x) {
/* computes cos of x (x in radians) by an expansion */
int i, factor;
float    result, power;

   result = 1.0f;
   factor = 1;
   power = x;
   for ( i = 2; i <= 10; i++ ) {
      factor = factor * i;  power = power*x;
      if ( (i & 1) == 0 )  {
        if ( (i & 3) == 0 ) result = result + power/factor;
		else result = result - power/factor;
      }
   }
   return (result);
}

int Min0( int arg1, int arg2) {
    if ( arg1 < arg2 ) 	return (arg1);
    else  return (arg2);
}

void Printcomplex(struct complex zarray[], int start, int finish, int increment) {     /* removed unused arg1, arg2 arguments WR*/
    int i;
    printf("\n") ;

    i = start;
    do {
		printf("  %15.3f%15.3f",zarray[i].rp,zarray[i].ip) ;
		i = i + increment;
		printf("  %15.3f%15.3f",zarray[i].rp,zarray[i].ip) ;
		printf("\n");
		i = i + increment ;
    } while ( i <= finish );

}

void Uniform11(int *iy, float *yfl) {
    *iy = (4855 * *iy + 1731) & 8191;
    *yfl = *iy/8192.0f;
} /* uniform */ 

void Exptab(int n, struct complex e[]) { /* exptab */
    float theta, divisor, h[26];
    int i, j, k, l, m;

    theta = 3.1415926536f;
    divisor = 4.0f;
    for ( i=1; i <= 25; i++ ) {
		h[i] = 1/(2*Cos( theta/divisor ));
		divisor = divisor + divisor;
	}

    m = n / 2 ;
    l = m / 2 ;
    j = 1 ;
    e[1].rp = 1.0f;
    e[1].ip = 0.0f;
    e[l+1].rp = 0.0f;
    e[l+1].ip = 1.0f;
    e[m+1].rp = -1.0f;
    e[m+1].ip = 0.0f;

    do {
		i = l / 2 ;
		k = i ;
	
		do {
		    e[k+1].rp = h[j]*(e[k+i+1].rp+e[k-i+1].rp) ;
		    e[k+1].ip = h[j]*(e[k+i+1].ip+e[k-i+1].ip) ;
		    k = k+l ;
		} while ( k <= m );
	
		j = Min0( j+1, 25);
		l = i ;
	} while ( l > 1 );

} /* exptab */

void Fft( int n, struct complex z[], struct complex w[], struct complex e[], float sqrinv) {
    int i, j, k, l, m, index;
    m = n / 2 ;
    l = 1 ;

    do {
		k = 0 ;
		j = l ;
		i = 1 ;
	
		do {
	
		    do {
			w[i+k].rp = z[i].rp+z[m+i].rp ;
			w[i+k].ip = z[i].ip+z[m+i].ip ;
			w[i+j].rp = e[k+1].rp*(z[i].rp-z[i+m].rp)
			-e[k+1].ip*(z[i].ip-z[i+m].ip) ;
			w[i+j].ip = e[k+1].rp*(z[i].ip-z[i+m].ip)
			+e[k+1].ip*(z[i].rp-z[i+m].rp) ;
			i = i+1 ;
		    } while ( i <= j );
	
		    k = j ;
		    j = k+l ;
		} while ( j <= m );
	
		/*z = w ;*/ index = 1;
		do {
		    z[index] = w[index];
		    index = index+1;
		} while ( index <= n );
		l = l+l ;
    } while ( l <= m );

    for ( i = 1; i <= n; i++ ){
		z[i].rp = sqrinv*z[i].rp ;
		z[i].ip = -sqrinv*z[i].ip;
	}

}

void Oscar() { /* oscar */
	int i;
	Exptab(fftsize,e) ;
	seed = 5767 ;
	for ( i = 1; i <= fftsize; i++ ) {
		int s = seed;
	    Uniform11( &s, &zr ); /* typecast seed for 16 bit WR*/
		seed = s;
	    Uniform11( &s, &zi ); /* typecast seed for 16 bit WR*/
		seed = s;
	    z[i].rp = 20.0f*zr - 10.0f;
	    z[i].ip = 20.0f*zi - 10.0f;
	}
	for ( i = 1; i <= 20; i++ ) {
	   Fft(fftsize,z,w,e,0.0625f) ;
	}
	    Printcomplex( z, 1, 256, 17 );   /* removed 1st 2 args 6, 99, unused by printcomplex WR*/
} /* oscar */ 

int main()
{
	int i;
	for (i = 0; i < 10; i++) Oscar();
	return 0;
}