-71

ROUTINE FOR NEGATIVE.SEGREGATION.CHECK

DEFINE W,T,X AS INTEGER VARIABLES

NORMALLY MODE IS INTEGER

FOR EACH HOUSE, DO

LET W = 0

FOR T = TODAY+1 TO LAST.DAY+1

ADD DUE RIGHT.NAME(HOUSE,T) TO W

LET W = MAX.F(O,MIN.F(W, SEGREGATION.REQUIREMENT-INITIAL.SEGREGATION))
LET X = RIGHT.NAME.INVENTORY + WRONG.NAME.INVENTORY + W

IF SEGREGATION REQUIREMENT > X

PRINT 1 DOUBLE LINE WITH HOUSE,X, SEGREGATION REQUIREMENT,
SEGREGATION.REQUIREMENT - X, TODAY THUS
INVENTORY + RIGHT NAME DUE-IN

--> FIRM *

DEFICIT

SEG REQUIREMENT

-72

ROUTINE TO SUM.DEMAND GIVEN FIRM AND METHOD

NORMALLY MODE IS INTEGER

DEFINE METHOD AS A SUBPROGRAM VARIABLE

LET TOTAL = 0

FOR EACH DELIVERY.ORDER IN FILE.OF.DELIVERY.ORDERS (FIRM)
WITH DATE(DELIVERY.ORDER)<=TODAY

DO

PERFORM METHOD YIELDING DECISION

IF DECISION = YES

ADD AMOUNT (DELIVERY.ORDER) TO TOTAL

REGARDLESS

REPEAT

RETURN WITH TOTAL

END

0017

-73

ROUTINE SORT GIVEN ARRAY

END

DEFINE I,START,SAVE.AMT,SAVE.FIRM,MAX.VAL,MAX.INDEX AS INTEGER

DEFINE ARRAY AS A 2-DIM, INTEGER ARRAY

LET START = 1

BEGIN.SORT'

FOR I = START TO N.HOUSE

VARIABLES

COMPUTE MAX.VAL AS THE MAX, MAX.INDEX = MAX(I) OF ARRAY(1,1)

LET SAVE.AMT = ARRAY(START,1)

LET SAVE.FIRM = ARRAY(START,2)

LET ARRAY(START,1) = MAX.VAL

LET ARRAY(START,2) = ARRAY(MAX.INDEX,2)

ADD 1 TO START

LET ARRAY(MAX.INDEX,1) = SAVE.AMT

LET ARRAY(MAX.INDEX,2) = SAVE.FIRM

IF START > N.HOUSE RETURN
ELSE

GO BEGIN.SORT

00

-74

ROUTINE TO FIND.DISTRIBUTION GIVEN ALPHA, MEAN, STD YIELDING PARAM.P1,
PARAM.P2,DIST,PARAM.MEAN, PARAM.STD

DEFINE MEAN, STD, PARAM.P1,PARAM.P2,PARAM.MEAN, PARAM.STD AS REAL VARIABLES
DEFINE DIST AS A SUBPROGRAM VARIABLE

LET PARAM.MEAN=(2*A**2*B+B**3-A**3) / (3*(A+B)*B)

LET PARAM.STD=SORT.F{(4*A**3*B+B**4-A**4) / (6*(A+ B)*B)-PARAM.MEAN**2) ELSE

RETURN
END

00

-75

ROUTINE FOR S.DEV (SUM.X,SQUARED.X,N)

NORMALLY MODE IS REAL

DEFINE N AS AN INTEGER VARIABLE

IF N <= 1 RETURN WITH O

OTHERWISE RETURN WITH

SORT.F((SQUARED.X - (SUM.X**2)/N) / (N-1))

END

ROUTINE FOR TRIANGLE.DIST(MODE,MAX, SEED)
DEFINE MODE,MAX AS REAL VARIABLES

DEFINE SEED AS AN INTEGER VARIABLE

DEFINE R AS A REAL VARIABLE

LET X = MAX-MODE

LET R = RANDOM.F(SEED)

IF MODE/MAX >= R

RETURN (SORT.F(MODE* ( (MODE+X)*R} } }

ELSE

RETURN WITH MODE + X+SORT.F(4*(MODE+X ) **2−4*(MODE+X)*(R*X+MODE}}/ (−2 )
END

ROUTINE EXPONENTIAL.F(MU, STD, STREAM)

DEFINE MU,STD AS REAL VARIABLES

DEFINE STREAM AS AN INTEGER VARIABLE

IF MU <= 0, LET ERR.F=132 ELSE

RETURN WITH -MU*LOG.E.F(RANDOM.F(STREAM))
END

00