#include <stdio.h>
#include <iomanip>
#include <math.h> // for log function
#include <iostream>
using namespace std;
// Global variables

long int seed = 56329; //This should be changed if you need to make
                       // different runs.

// Function to generate uniformly distributed random
//   numbers between 0 and 1.

double random( long int* seed )

  // Warning:  random number generators are, by their
  //   nature, very machine dependent. This generator
  //   will require modification if not run on a
  //   machine with at least a 32 bit word for
  //   integers.

/* Park & Miller function (see CACM Oct. 88) integer version */
/* of their generator.                                       */
/* This should work correctly if largest integer is 2^31 - 1 */
/* or larger.                                                */

{  // function random
	long int  a = 16807,        // 7^5
	          m = 2147483647,   // 2^31 - 1
		  q = 127773,           // m / a (int divide)
		  r = 2836,		        // m % a
		  lo, hi, test;
	double dm = 2147483647;

	hi = *seed / q;
	lo = *seed % q;
	test = a * lo - r * hi;
	*seed = test > 0 ? test : test + m;
	return (double)(*seed/dm);
}  // function random

double exponential(float mean)
{ // function exponential
       return (double)(-mean*log(random(&seed)));
} // function exponential


// Generate process attributes:  primary memory size, 
//   execution time (memory references), process type,
//   priority, generation time

void parameters(int   ave_interarrival_time, //between process arrivals
                    int   last_arival_time, //last process arrival time
                    int max_CPU_size,   //Maximum CPU Burst Size
                    int min_CPU_size,   // Minimum CPU Burst Size
                    int* priority,          //Priority
                    long*  arrival_time, //Time of arrival
                    int* CPU_burst_size) //CPU Burst Size

  // Procedures called:
  //   random:  to generate uniformly distributed random variates.
 //    exponential: to generate exponentially distributed random variates
  // Global variables:
  //   seed:  used by function random.

{ // function parameters
  *priority = 1 + int(9*random(&seed)); //generates priority between 1 and 10
  *arrival_time = (long) (last_arival_time + exponential((float) (ave_interarrival_time)) + 0.5);
  *CPU_burst_size = min_CPU_size + int((max_CPU_size-min_CPU_size)*random(&seed)); // generates CPU Burst size
} // function parameters

                      
int main()

{
  int   hist[10];
  int   index;
  int   i;

  int   max_CPU_burst, min_CPU_burst;
  int   this_CPU_burst_length;
  int   this_priority;
  int   ave_interarr_time;
  int last_arrival_time = 0;
  long this_arrival_time;
  int temp;

  cout << "Maximum CPU Burst: ";
  cin >>   max_CPU_burst;
  cout << "Minimum CPU Burst: ";
  cin >>   min_CPU_burst;
  cout << "Average Interarrival Time: ";
  cin >>   ave_interarr_time;

// Assuming that there are 20 processes 
cout << "Index " << "Arrival time  "<< "CPU Burst Length " << "  Priority" << endl;
    for ( i=1; i<=20; i++ )
	{
      parameters(ave_interarr_time, last_arrival_time, max_CPU_burst, min_CPU_burst, &this_priority, &this_arrival_time, &this_CPU_burst_length);
      cout << setw( 4 ) << i << setw(12)  << this_arrival_time << setw( 20) << this_CPU_burst_length;
        cout << setw(6) << this_priority << endl;
        last_arrival_time = this_arrival_time;
    }
return 0;
  } // function main