SUBROUTINE SUBTRACT_4BYTE_COUNTER( A, B, DIFFERENCE) C---------------------------------------------------------------------- C- C- Purpose and Methods : To subtract two four byte counts (A - B) taking C- into account the possibility of the counts rolling C- over. C- C- Inputs : A,B 4 byte counts to be subtracted C- C- Outputs : DIFFERENCE result of the subtraction C- Controls: C- C- Created 21-JUL-1994 Philippe Laurens, Freddie Landry C- C---------------------------------------------------------------------- IMPLICIT NONE INTEGER A, B, DIFFERENCE C INTEGER BYTE_LENGTH, BYTE_2, BYTE_3, BYTE_4 PARAMETER (BYTE_LENGTH = 8) INTEGER LOW_WORD, HIGH_WORD PARAMETER (LOW_WORD = 1, HIGH_WORD = 2) PARAMETER( BYTE_2 = 8, BYTE_3 = 16, BYTE_4 =24) INTEGER LOW_WORD_MAX, HIGH_WORD_MAX PARAMETER( LOW_WORD_MAX= 16777215) ! 2**24 -1 PARAMETER( HIGH_WORD_MAX = 255) ! 2**8 -1 INTEGER INTA(LOW_WORD:HIGH_WORD) INTEGER INTB(LOW_WORD:HIGH_WORD) INTEGER FOUR_BYTE_MAX(LOW_WORD:HIGH_WORD) C C **** Putting both counts into 1 byte:3 bytes format C INTA(LOW_WORD) = IBITS( A, 0, 3*BYTE_LENGTH ) INTA(HIGH_WORD) = IBITS( A, BYTE_4, BYTE_LENGTH) INTB(LOW_WORD) = IBITS( B, 0, 3*BYTE_LENGTH ) INTB(HIGH_WORD) = IBITS( B, BYTE_4, BYTE_LENGTH) FOUR_BYTE_MAX(LOW_WORD) = LOW_WORD_MAX FOUR_BYTE_MAX(HIGH_WORD) = HIGH_WORD_MAX CALL SUBTRACT_COUNTERS( INTA, INTB, FOUR_BYTE_MAX, & DIFFERENCE) RETURN END C---------------------------------------------------------------------- SUBROUTINE SUBTRACT_5BYTE_COUNTER(A, B, DIFFERENCE) C---------------------------------------------------------------------- C- C- Purpose and Methods : Find the difference between two five byte C- quantities. The difference is rounded to the nearest 4 byte quantity. C- (DIFFERENECE = A - B) C- C- Inputs : A Array of 2 integers in UNITS,GIGAS format C- B Array of 2 integers in UNITS,GIGAS format C- C- Outputs : DIFFERENCE the 32 bit difference A - B C- Controls: none C- C- Created 12-JUL-1994 Philippe Laurens, Freddie Landry C---------------------------------------------------------------------- IMPLICIT NONE INTEGER A(2), B(2), DIFFERENCE C INTEGER LOW_WORD, HIGH_WORD PARAMETER (LOW_WORD = 1, HIGH_WORD = 2) INTEGER BYTE_LENGTH,BYTE_2,BYTE_3,BYTE_4 PARAMETER( BYTE_2 =8, BYTE_3 =16, BYTE_4 =24) PARAMETER (BYTE_LENGTH = 8) INTEGER LOW_WORD_MAX, HIGH_WORD_MAX PARAMETER( LOW_WORD_MAX= 16777215) ! 2**24 -1 PARAMETER( HIGH_WORD_MAX= 65535) ! 2**16 -1 C INTEGER INTA(LOW_WORD:HIGH_WORD) INTEGER INTB(LOW_WORD:HIGH_WORD) INTEGER FIVE_BYTE_MAX(LOW_WORD:HIGH_WORD) C C UNITS:GIGAS => 3 BYTES:2 BYTES C INTA(LOW_WORD) = IBITS( A(LOW_WORD), 0, 3*BYTE_LENGTH ) INTA(HIGH_WORD) = IBITS(A(LOW_WORD), BYTE_4, 6) CALL MVBITS(A(HIGH_WORD), 0, BYTE_LENGTH +2, & INTA(HIGH_WORD), BYTE_2 -2 ) INTB(LOW_WORD) = IBITS(B(LOW_WORD), 0, 3*BYTE_LENGTH) INTB(HIGH_WORD) = IBITS(B(LOW_WORD), BYTE_4, 6) CALL MVBITS(B(HIGH_WORD), 0, BYTE_LENGTH+2, & INTB(HIGH_WORD), BYTE_2 -2 ) FIVE_BYTE_MAX(LOW_WORD) = LOW_WORD_MAX FIVE_BYTE_MAX(HIGH_WORD) = HIGH_WORD_MAX CALL SUBTRACT_COUNTERS( INTA, INTB, FIVE_BYTE_MAX, & DIFFERENCE) RETURN END C####################################################################### SUBROUTINE SUBTRACT_COUNTERS( INTA, INTB, SCALER_MAX, DIFFERENCE) C---------------------------------------------------------------------- C- C- Purpose and Methods : Calculate INTA - INTB, where INTA and INTB C- are either 4 or 5 byte counters of a certain C- quantity. A negative result is treated as C- the counter having rolled over. C- C- Inputs : INTA, INTB -> two element arrays containing the counters C- to be subtracted with the following format: C- INTA(1) lowest 3 bytes C- INTA(2) remaining high bytes C- SCALER_MAX -> maximum possible value for the counter in C- the same format as INTA & INTB. C- For a 5 byte counter it is: C- SCALER_MAX(1) = 2**24 - 1 C- SCALER_MAX(2) = 2**16 - 1 C- C- Outputs : DIFFERENCE -> 4 byte result of subtraction C- C- Controls: none C- C- Created 3-AUG-1994 Philippe Laurens, Freddie Landry C- Updated 26-AUG-1994 Philippe Laurens, Freddie Landry C- the counter is now only considered to have C- rolled over if the highest bit in INTB is 1. C- Otherwise, the difference will be negative. C---------------------------------------------------------------------- IMPLICIT NONE C---------------------------------------------------------------------- INTEGER INTA(2), INTB(2), SCALER_MAX(2), DIFFERENCE INTEGER LOW_WORD, HIGH_WORD PARAMETER (LOW_WORD = 1, HIGH_WORD = 2) INTEGER BYTE_LENGTH,BYTE_2,BYTE_3,BYTE_4 PARAMETER( BYTE_2 =8, BYTE_3 =16, BYTE_4 =24) PARAMETER (BYTE_LENGTH = 8) INTEGER INTC(2), STORE_A(2), HI_BIT, SWAP LOGICAL NEGATIVE, HI_BIT_UP, ROLLOVER INTEGER BIGNUM PARAMETER (BIGNUM = 2147483647) ! 2**31 - 1 C C **** Finding the highest bit that can be filled in INTB( HIGH_WORD) C IF ( SCALER_MAX( HIGH_WORD) .EQ. 255) THEN C C **** subtracting 4 byte counters so HI_BIT is... C HI_BIT = 7 ! most significant bit of 1 byte ELSE C C **** subtracting 5 byte counters so HI_BIT is... C HI_BIT = 15 ! most significant bit of 2 bytes ENDIF C C **** Checking if INTA < INTB C NEGATIVE = ((INTA(HIGH_WORD) .LT. INTB(HIGH_WORD)) & .OR. ((INTA(LOW_WORD) .LT. INTB(LOW_WORD)) & .AND. (INTA(HIGH_WORD) .LE. INTB(HIGH_WORD)))) C C **** HI_BIT_UP will be true if the most significant bit in INTB is 1 C HI_BIT_UP = IBITS( INTB(HIGH_WORD), HI_BIT, 1) .EQ. 1 IF (NEGATIVE .AND. HI_BIT_UP) THEN C C **** So the counter has rolled over, and the true difference is C **** difference between the maximum 5 byte scaler value and B, C **** added to A. C ROLLOVER = .TRUE. NEGATIVE = .FALSE. IF ( INTA(HIGH_WORD) .GE. 2**(BYTE_LENGTH-1) ) THEN DIFFERENCE = BIGNUM RETURN ELSE STORE_A( LOW_WORD) = INTA( LOW_WORD) STORE_A( HIGH_WORD) = INTA( HIGH_WORD) INTA( LOW_WORD) = SCALER_MAX( LOW_WORD) INTA( HIGH_WORD) = SCALER_MAX( HIGH_WORD) ENDIF C ELSE C C **** If the count has not rolled over, check to see if it's necessary C **** to carry a 1 from a higher bit position C ROLLOVER = .FALSE. IF (NEGATIVE) THEN SWAP = INTA(LOW_WORD) INTA(LOW_WORD) = INTB(LOW_WORD) INTB(LOW_WORD) = SWAP SWAP = INTA(HIGH_WORD) INTA(HIGH_WORD) = INTB(HIGH_WORD) INTB(HIGH_WORD) = SWAP ENDIF IF (INTA(LOW_WORD) .LT. INTB(LOW_WORD)) THEN INTA(LOW_WORD) = INTA(LOW_WORD) + 2**(BYTE_LENGTH*3) INTA(HIGH_WORD) = INTA(HIGH_WORD) - 1 ENDIF ENDIF C C **** Now calculate the difference C INTC(LOW_WORD) = INTA(LOW_WORD) - INTB(LOW_WORD) INTC(HIGH_WORD) = INTA(HIGH_WORD) - INTB(HIGH_WORD) C IF ( ROLLOVER .EQV. .TRUE. ) THEN INTC(LOW_WORD) = INTC(LOW_WORD) + STORE_A(LOW_WORD) + 1 INTC(HIGH_WORD) = INTC(HIGH_WORD) + STORE_A(HIGH_WORD) & + IBITS( INTC(LOW_WORD), BYTE_4, BYTE_LENGTH) INTC(LOW_WORD) = IBITS( INTC(LOW_WORD), 0, 3*BYTE_LENGTH) END IF IF (INTC(HIGH_WORD) .GE. 2**(BYTE_LENGTH-1) ) THEN DIFFERENCE = BIGNUM ELSE DIFFERENCE = INTC(LOW_WORD) CALL MVBITS(INTC(HIGH_WORD),0, BYTE_LENGTH-1, & DIFFERENCE, BYTE_4) ENDIF IF (NEGATIVE) THEN DIFFERENCE = -DIFFERENCE ENDIF C C---------------------------------------------------------------------- 999 RETURN END