C ORDM01    SOURCE    JC220346  14/12/16    21:15:03     8324
************************************************************************
* NOM         : ORDM01
* DESCRIPTION : Tri par fusion (Merge Sort) pour une liste de reels
************************************************************************
* APPELE PAR : pilot.eso
************************************************************************
* ENTREES :: A      = liste de reels a trier
*            N      = longueur de la liste A
*            T      = tableau de travail de reels de longueur (N+1)/2
*            CROISS = booleen indiquant l'ordre du tri
* SORTIES :: A      = liste triee
************************************************************************
      RECURSIVE SUBROUTINE ORDM01(A,N,T,CROISS)
*
      INTEGER   I,J,K,N,NA,NB
      REAL*8    A,T,V
      DIMENSION A(N),T((N+1)/2)
      LOGICAL   CROISS,DECROI
*
*     On arrete la recursion pour N=1 ou N=2
      IF (N.LT.2) RETURN
      DECROI = .NOT.CROISS
      IF (N.EQ.2) THEN
          IF ((CROISS.AND.A(1).GT.A(2)).OR.
     &        (DECROI.AND.A(1).LT.A(2))) THEN
              V = A(1)
              A(1) = A(2)
              A(2) = V
          ENDIF
          RETURN
      ENDIF
*
*     Sinon, on subdivise en deux sous-listes plus petites que l'on
*     va ordonner separement
      NA=(N+1)/2
      NB=N-NA
      CALL ORDM01(A,NA,T,CROISS)
      CALL ORDM01(A(NA+1),NB,T,CROISS)
*
*     On melange les deux petites sous-listes en une grande liste
*     ordonnee (avec un peu de chance, il n'y a rien a faire...)
      IF ((CROISS.AND.A(NA).GT.A(NA+1)).OR.
     &    (DECROI.AND.A(NA).LT.A(NA+1))) THEN
          T(1:NA)=A(1:NA)
          I = 1
          J = 1
          K = 1
          DO WHILE (I.LE.NA.AND.J.LE.NB)
              V = A(NA+J)
              IF ((CROISS.AND.T(I).LE.V).OR.
     &            (DECROI.AND.T(I).GE.V)) THEN
                  A(K) = T(I)
                  I = I+1
              ELSE
                  A(K) = V
                  J = J+1
              ENDIF
              K = K + 1
          ENDDO
*
          DO WHILE (I.LE.NA)
              A(K) = T(I)
              I = I + 1
              K = K + 1
          ENDDO
      ENDIF
*
      RETURN
*
      END
*