CTITLEFIXFLH -- CONVERT A HALFWORD INTEGER ARRAY TO A REAL ARRAY        00010000
C***********************************************************************
C                 COPYRIGHT ATLANTIC RICHFIELD COMPANY 1991            *
C***********************************************************************
CA    AUTHOR               STU NELAN                                    00020000
CA    DESIGNER             STU NELAN                                    00030000
CA    LANGUAGE             FORTRAN                                      00040001
CA    SYSTEM               IBM (SEE CRAY)                               00050002
CA    WRITTEN              10-26-84                                     00060000
C     REVISED              07-11-86 ESN. FOR USE ON THE IBM.            00070001
C     REVISED              09-04-86 JMP. DE-VECTORIZE THE LOOP TO ALLOW 00070002
C                                   OVERLAPPING INPUT ARRAYS.           00070003
CA                                                                      00080000
CA                                                                      00090000
CA    CALL FIXFLH (IA, B, N)                                            00100000
CA          INPUT   IA = HALFWORD INTEGER ARRAY                     I2  00110000
CA          OUTPUT   B = REAL ARRAY                                 R4  00120000
CA          INPUT    N = NUMBER OF ELEMENTS IN EACH ARRAY IA AND B  I4  00130000
CA                                                                      00140000
CA                                                                      00150000
CA       FIXFLH CONVERTS THE INTEGER ELEMENT IA(I), OF THE HALFWORD,    00160000
CA       TO FLOATING POINT (REAL) AND STORES THE REAL VALUE IN          00170000
CA       B(I), WHERE I RUNS FROM N TO 1.  THE INPUT ARRAYS IA AND B     00180000
CA       MAY BE OVERLAPPED.                                             00180100
CA                                                                      00190000
CAEND                                                                   00200000
      SUBROUTINE FIXFLH ( IA, B, N )                                    00210000
C                                                                       00220000
      INTEGER*2  IA (2)                                                 00230000
      REAL       B  (2)                                                 00240000
C                                                                       00250000
      IF ( N.LE.0 ) RETURN                                              00260000
C                                                                       00270000
      I = N                                                             00270100
C                                                                       00270110
C             SCALAR LOOP SO THAT OVERLAPPING ARRAYS MAY BE             00270120
C             USED AS INPUT.                                            00270130
C                                                                       00270140
   10 CONTINUE                                                          00270200
      B(I) = IA(I)                                                      00290000
      I = I - 1                                                         00290100
      IF (I .GE. 1) GO TO                                            10 00290200
C                                                                       00300000
      RETURN                                                            00310000
C                                                                       00320000
      END                                                               00330000