anchor.diff:         MATRIX(J,K) = TMP
        END DO
     END IF
  -END SUBROUTINE MATRIX_PARTIAL_PIVOT
  -!----------------------------------------------------------------------------------------------------------------------------------+
  -SUBROUTINE MATRIX_GAUSS_JORDAN_ELIMINATE_COLUMN(MATRIX,COL)
  -!----------------------------------------------------------------------------------------------------------------------------------+
  -! Performs Gauss elimination on a particular column.
  -!----------------------------------------------------------------------------------------------------------------------------------+
  -  IMPLICIT NONE
  -  REAL(KIND=8),INTENT(INOUT),DIMENSION(:,:) :: MATRIX ! The matrix on which the elimination is performed.
  -  INTEGER(KIND=4),INTENT(IN)                :: COL    ! The column to be zeroed out.
  -  INTEGER(KIND=4)                           :: J      ! Iteration index.
  -!----------------------------------------------------------------------------------------------------------------------------------+
  -! Performs Gauss elimination on a particular column.  This procedure is called multiple times to columns for Gauss-Jordan
  -! elimination.  Consider the following matrix:
  -!   
  -!                                               | A11 A12 A13 A14 A15 A16 A17 |
  -!                                               | 0.0 A22 A23 A24 A25 A26 A27 |
  -!                                               | 0.0 A32 A33 A34 A35 A36 A37 |
  -!                                               | 0.0 A42 A43 A44 A45 A46 A47 |
  -!                                               | 0.0 A52 A53 A54 A55 A56 A57 |
  -!
  -!
  -! Column 2 is the next to be zeroed.  This is done by repeated calls  to GAUSS_JORDAN_ELIMINATE_ROW.  The result is the
  -! following:
  -!
  -!                                               | A11 0.0 A13 A14 A15 A16 A17 |
  -!                                               | 0.0 A22 A23 A24 A25 A26 A27 |
  -!                                               | 0.0 0.0 A33 A34 A35 A36 A37 |
  -!                                               | 0.0 0.0 A43 A44 A45 A46 A47 |
  -!                                               | 0.0 0.0 A53 A54 A55 A56 A57 |
  -!
  -! Note:  This procedure calls GAUSS_JORDAN_ELIMINATE_ROW for every row in the matrix.  Repeated calls, result in a matrix with non-
  -! zero values only on the diagonal.  This is less efficient that elimination resulting in a upper diagonal matrix to be used for
  -! backward substitution.
  -!----------------------------------------------------------------------------------------------------------------------------------+
  -  DO J = 1, SIZE(MATRIX,1)
  -    IF (J.NE.COL) CALL MATRIX_GAUSS_ELIMINATE_ROW(MATRIX,J,COL,1)
  -  END DO
  -END SUBROUTINE MATRIX_GAUSS_JORDAN_ELIMINATE_COLUMN
  -!----------------------------------------------------------------------------------------------------------------------------------+
  -SUBROUTINE MATRIX_GAUSS_ELIMINATE_ROW(MATRIX,ROW,COL,SCOL)
  +END SUBROUTINE PARTIAL_PIVOT
  +!----------------------------------------------------------------------------------------------------------------------------------+
  +SUBROUTINE MODLINALG_GAUSS_ELIMINATE_ROW(MATRIX,ROW,COL,SCOL)
   !----------------------------------------------------------------------------------------------------------------------------------+
   ! Performs Gauss elimination on a particular row.
   !----------------------------------------------------------------------------------------------------------------------------------+
  
positive.code:   CALL MATRIX_PRINT(E)
  !----------------------------------------------------------------------------------------------------------------------------------+
    WRITE(6,900)
    WRITE(6,980)'RUNNING GAUSS-JORDAN ELIMINATION ON [D]'
    WRITE(6,900)
    CALL MATRIX_GAUSS_JORDAN_ELIMINATION(D)
    CALL MATRIX_PRINT(D)
  !----------------------------------------------------------------------------------------------------------------------------------+
    WRITE(6,900)
  
negative.code: USE MODLINALG
    IMPLICIT NONE
    CALL TEST_MODLINALG
  !  REAL(KIND=8),DIMENSION(3,3) :: A, B
  !  REAL(KIND=8),DIMENSION(3,3) :: C
  !
  !  CALL MATRIX_RANDOMIZE(A)
  !  CALL MATRIX_RANDOMIZE(B)
  !
  !  CALL MATRIX_PRINT(A)
  !  WRITE(6,*)
  !  CALL MATRIX_PRINT(B)
  !  WRITE(6,*)
  !  C = A + B
  !  CALL MATRIX_PRINT(C)
  !  WRITE(6,*)
  !  C = A * B
  !  CALL MATRIX_PRINT(C)
  END PROGRAM LINAGLTEST
  