/* -------------------------------------------------------------------------   * This program is a next-event simulation of a simple inventory system with  * a Poisson demand process, backlogging, and a Uniform(0,1) delivery lag.  * * Name              : sis3.c  (Simple Inventory System, version 3)  * Author            : Steve Park & Dave Geyer  * Language          : ANSI C  * Latest Revision   : 10-19-98  * -------------------------------------------------------------------------  */#include <stdio.h>#include <math.h>#include "rngs.h"#define MINIMUM    20             /* 's' inventory policy parameter >= 0 */#define MAXIMUM    80             /* 'S' inventory policy parameter > s  */#define START      0.0#define STOP       100.0#define INFINITY   (100.0 * STOP)    double Exponential(double m)/* --------------------------------------------------- * generate an Exponential random variate, use m > 0.0  * --------------------------------------------------- */{  return (-m * log(1.0 - Random()));}   double Uniform(double a, double b)  /* -------------------------------------------- * generate a Uniform random variate, use a < b  * -------------------------------------------- */{  return (a + (b - a) * Random());  }   double GetDemand(void)/* -------------------------------------------------------------- * generate the next demand instance (time) with rate 30 per time  * interval and exactly one unit of demand per demand instance  * -------------------------------------------------------------- */{               static double time = START;                              SelectStream(0);  time += Exponential(1.0 / 30.0);  return (time);}   double GetLag(void)/* ------------------------------ * generate a delivery lag (time)  * ------------------------------ */{                                           SelectStream(1);  return (Uniform(0.0, 1.0));}   double Min(double a, double b, double c)    /* ---------------------------------------- * return the smallest of a, b, c * ---------------------------------------- */{  double t = a;  if (b < t)    t = b;  if (c < t)    t = c;  return (t);}  int main(void){  long inventory = MAXIMUM;            /* current inventory level */  long order     = 0;                  /* current order level     */  struct {    double demand;                     /* next demand time                */    double review;                     /* next inventory review time      */    double arrive;                     /* next order arrival time         */    double current;                    /* current time                    */    double next;                       /* next (most imminent) event time */  } t;  struct {                             /* sum of -                */    double setup;                      /*   setup instances       */    double holding;                    /*   inventory held (+)    */    double shortage;                   /*   inventory short (-)   */    double order;                      /*   orders                */    double demand;                     /*   demands               */    double lag;                        /*   lags                  */  } sum          = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0};  PlantSeeds(0);  t.current = START;  t.demand  = GetDemand();              /* schedule the first demand */  t.review  = t.current + 1.0;          /* schedule the first review */  t.arrive  = INFINITY;                 /* no order arrival pending  */  while (t.current < STOP) {    t.next          = Min(t.demand, t.review, t.arrive);    if (inventory > 0)      sum.holding  += (t.next - t.current) * inventory;    else      sum.shortage -= (t.next - t.current) * inventory;    t.current       = t.next;    if (t.current == t.demand) {        /* process an inventory demand */      sum.demand++;      inventory--;      t.demand = GetDemand();    }    else if (t.current == t.review) {   /* process inventory review */      if (inventory < MINIMUM) {        double lag;        order      = MAXIMUM - inventory;        lag        = GetLag();        sum.setup++;        sum.order += order;        sum.lag   += lag;        t.arrive   = t.current + lag;      }      t.review  = t.current + 1.0;    }    else {                           /* process an inventory order arrival*/      inventory += order;      order      = 0;      t.arrive   = INFINITY;    }  }   if (inventory < MAXIMUM) {          /* adjust the final inventory level */    order      = MAXIMUM - inventory;    sum.setup++;    sum.order += order;    inventory += order;  }  printf("\nfor %ld time intervals ", (long) STOP);  printf("with an average demand of %6.2f\n", sum.demand / STOP);  if (sum.setup > 0.0)    printf("an average lag of %4.2f", sum.lag / sum.setup);  printf(" and policy parameters (s, S) = (%d, %d)\n\n", MINIMUM, MAXIMUM);  printf("   average order ............ = %6.2f\n", sum.order / STOP);  printf("   setup frequency .......... = %6.2f\n", sum.setup / STOP);  printf("   average holding level .... = %6.2f\n", sum.holding / STOP);  printf("   average shortage level ... = %6.2f\n\n", sum.shortage / STOP);  return (0);}