double_linked_list.F

Go to the documentation of this file.

C
C  This file is part of MUMPS 5.5.1, released
C  on Tue Jul 12 13:17:24 UTC 2022
C
C
C  Copyright 1991-2022 CERFACS, CNRS, ENS Lyon, INP Toulouse, Inria,
C  Mumps Technologies, University of Bordeaux.
C
C  This version of MUMPS is provided to you free of charge. It is
C  released under the CeCILL-C license 
C  (see doc/CeCILL-C_V1-en.txt, doc/CeCILL-C_V1-fr.txt, and
C  https://cecill.info/licences/Licence_CeCILL-C_V1-en.html)
C
      MODULE mumps_idll
      IMPLICIT NONE
      TYPE idll_node_t
          TYPE ( idll_node_t ), POINTER :: next, prev
          INTEGER elmt
      END TYPE idll_node_t
      TYPE idll_t
          TYPE ( idll_node_t ), POINTER :: front, back
      END TYPE idll_t
      CONTAINS
      FUNCTION idll_create(DLL)
          INTEGER :: idll_create
#if defined(mumps_f2003)
          TYPE ( idll_t ), POINTER, INTENT ( OUT ) :: dll
#else
          TYPE ( idll_t ), POINTER :: dll
#endif
          INTEGER ierr
          ALLOCATE ( dll, stat=ierr )
          IF ( ierr .NE. 0 ) THEN
              idll_create = -2
              RETURN
          END IF
          NULLIFY ( dll%FRONT )
          NULLIFY ( dll%BACK )
          idll_create = 0
          RETURN
      END FUNCTION idll_create
      FUNCTION idll_destroy(DLL)
          INTEGER :: idll_destroy
#if defined(mumps_f2003)
          TYPE ( idll_t ), POINTER, INTENT ( OUT ) :: dll
#else
          TYPE ( idll_t ), POINTER :: dll
#endif
          TYPE ( idll_node_t ), POINTER :: aux
          IF ( .NOT. associated ( dll ) ) THEN
              idll_destroy = -1
              RETURN
          END IF
          DO WHILE ( associated ( dll%FRONT ) )
              aux => dll%FRONT
              dll%FRONT => dll%FRONT%NEXT
              DEALLOCATE( aux )
          END DO
          DEALLOCATE( dll )
          idll_destroy = 0
      END FUNCTION idll_destroy
      FUNCTION idll_push_front(DLL, ELMT)
          INTEGER :: idll_push_front
#if defined(mumps_f2003)
          TYPE ( idll_t ), POINTER, INTENT ( INOUT ) :: dll
#else
          TYPE ( idll_t ), POINTER :: dll
#endif
          INTEGER, INTENT ( IN ) :: elmt
          TYPE ( idll_node_t ), POINTER :: node
          INTEGER ierr
          IF ( .NOT. associated ( dll ) ) THEN
              idll_push_front = -1
              RETURN
          END IF
          ALLOCATE( node, stat=ierr )
          IF ( ierr .NE. 0 ) THEN
              idll_push_front = -2
              RETURN
          END IF
          node%ELMT = elmt
          node%NEXT => dll%FRONT
          NULLIFY ( node%PREV )
          IF ( associated ( dll%FRONT ) ) THEN
              dll%FRONT%PREV => node
          END IF
          dll%FRONT => node
          IF ( .NOT. associated ( dll%BACK ) ) THEN
              dll%BACK => node
          END IF
          idll_push_front = 0
      END FUNCTION idll_push_front
      FUNCTION idll_pop_front(DLL, ELMT)
          INTEGER :: idll_pop_front
#if defined(mumps_f2003)
          TYPE ( idll_t ), POINTER, INTENT ( INOUT ) :: dll
#else
          TYPE ( idll_t ), POINTER :: dll
#endif
          INTEGER, INTENT ( OUT ) :: elmt
          TYPE ( idll_node_t ), POINTER :: AUX
          IF ( .NOT. associated ( dll ) ) THEN
              idll_pop_front = -1
              RETURN
          END IF
          IF ( .NOT. associated ( dll%FRONT ) ) THEN
              idll_pop_front = -3
              RETURN
          END IF
          elmt = dll%FRONT%ELMT
          aux => dll%FRONT
          dll%FRONT => dll%FRONT%NEXT
          IF ( associated ( dll%FRONT ) ) THEN
              NULLIFY ( dll%FRONT%PREV )
          END IF
          IF ( associated ( dll%BACK, aux ) ) THEN
              NULLIFY ( dll%BACK )
          END IF
          DEALLOCATE ( aux )
          idll_pop_front = 0
      END FUNCTION idll_pop_front
      FUNCTION idll_push_back(DLL, ELMT)
          INTEGER :: idll_push_back
#if defined(mumps_f2003)
          TYPE ( idll_t ), POINTER, INTENT ( INOUT ) :: dll
#else
          TYPE ( idll_t ), POINTER :: dll
#endif
          INTEGER, INTENT ( IN ) :: elmt
          TYPE ( idll_node_t ), POINTER :: node
          INTEGER ierr
          IF ( .NOT. associated ( dll ) ) THEN
              idll_push_back = -1
              RETURN
          END IF
          ALLOCATE( node, stat=ierr )
          IF ( ierr .NE. 0 ) THEN
              idll_push_back = -2
              RETURN
          END IF
          node%ELMT = elmt
          NULLIFY ( node%NEXT )
          node%PREV => dll%BACK
          IF ( associated ( dll%BACK ) ) THEN
              dll%BACK%NEXT => node
          END IF
          dll%BACK => node
          IF ( .NOT. associated ( dll%FRONT ) ) THEN
              dll%FRONT => node
          END IF
          idll_push_back = 0
      END FUNCTION idll_push_back
      FUNCTION idll_pop_back(DLL, ELMT)
          INTEGER :: idll_pop_back
#if defined(mumps_f2003)
          TYPE ( idll_t ), POINTER, INTENT ( INOUT ) :: dll
#else
          TYPE ( idll_t ), POINTER :: dll
#endif
          INTEGER, INTENT ( OUT ) :: elmt
          TYPE ( idll_node_t ), POINTER :: aux
          IF ( .NOT. associated ( dll ) ) THEN
              idll_pop_back = -1
              RETURN
          END IF
          IF ( .NOT. associated ( dll%BACK ) ) THEN
              idll_pop_back = -3
              RETURN
          END IF
          elmt = dll%BACK%ELMT
          aux => dll%BACK
          dll%BACK => dll%BACK%PREV
          IF ( associated ( dll%BACK ) ) THEN
              NULLIFY ( dll%BACK%NEXT )
          END IF
          IF ( associated ( dll%FRONT, aux ) ) THEN
              NULLIFY ( dll%FRONT )
          END IF
          DEALLOCATE ( aux )
          idll_pop_back = 0
      END FUNCTION idll_pop_back
      FUNCTION idll_insert(DLL, POS, ELMT)
          INTEGER :: idll_insert
#if defined(mumps_f2003)
          TYPE ( idll_t ), POINTER, INTENT ( INOUT ) :: dll
#else
          TYPE ( idll_t ), POINTER :: dll
#endif
          INTEGER, INTENT ( IN ) :: pos, elmt
          TYPE ( idll_node_t ), POINTER :: node
          TYPE ( idll_node_t ), POINTER :: new_ptr, old_ptr
          INTEGER :: ierr, cpt
          IF ( .NOT. associated ( dll ) ) THEN
              idll_insert = -1
              RETURN
          END IF
          IF ( pos .LE. 0 ) THEN
              idll_insert = -4
              RETURN
          END IF
          cpt = 1
          new_ptr => dll%FRONT
          NULLIFY ( old_ptr )
          DO WHILE ( ( cpt .LT. pos ) .AND.
     &               ( associated ( new_ptr ) ) )
              old_ptr => new_ptr
              new_ptr => new_ptr%NEXT
              cpt = cpt + 1
          END DO
          ALLOCATE ( node, stat=ierr )
          IF ( ierr .NE. 0 ) THEN
              idll_insert = -2
              RETURN
          END IF
          node%ELMT = elmt
          IF ( .NOT. associated ( old_ptr ) ) THEN
              IF ( .NOT. associated ( new_ptr ) ) THEN
                  NULLIFY ( node%PREV )
                  NULLIFY ( node%NEXT )
                  dll%FRONT => node
                  dll%BACK => node
              ELSE
                  NULLIFY ( node%PREV )
                  node%NEXT => new_ptr
                  new_ptr%PREV => node
                  dll%FRONT => node
              END IF
          ELSE
              IF ( .NOT. associated ( new_ptr ) ) THEN
                  node%PREV => old_ptr
                  NULLIFY ( node%NEXT )
                  old_ptr%NEXT => node
                  dll%BACK => node
              ELSE
                  node%PREV => old_ptr
                  node%NEXT => new_ptr
                  old_ptr%NEXT => node
                  new_ptr%PREV => node
              END IF
          END IF
          idll_insert = 0
      END FUNCTION idll_insert
      FUNCTION idll_insert_before(DLL, NODE_AFTER, ELMT)
          INTEGER :: idll_insert_before
#if defined(mumps_f2003)
          TYPE ( idll_t ), POINTER, INTENT ( INOUT ) :: dll
          TYPE ( idll_node_t ), POINTER, INTENT ( IN ) :: node_after
#else
          TYPE ( idll_t ), POINTER :: dll
          TYPE ( idll_node_t ), POINTER :: node_after
#endif
          INTEGER, INTENT ( IN ) :: elmt
          TYPE ( idll_node_t ), POINTER :: node_before
          INTEGER :: ierr
          ALLOCATE ( node_before, stat=ierr )
          IF ( ierr .NE. 0 ) THEN
              idll_insert_before = -2
              RETURN
          END IF
          node_before%ELMT = elmt
          IF ( .NOT. associated ( node_after%PREV ) ) THEN
              node_after%PREV => node_before
              node_before%NEXT => node_after
              NULLIFY ( node_before%PREV )
              dll%FRONT => node_before
          ELSE
              node_before%NEXT => node_after
              node_before%PREV => node_after%PREV
              node_after%PREV => node_before
              node_before%PREV%NEXT => node_before
          END IF
          idll_insert_before = 0
      END FUNCTION idll_insert_before
      FUNCTION idll_insert_after(DLL, NODE_BEFORE, ELMT)
          INTEGER :: idll_insert_after
#if defined(mumps_f2003)
          TYPE ( idll_t ), POINTER, INTENT ( INOUT ) :: dll
          TYPE ( idll_node_t ), POINTER, INTENT ( IN ) :: node_before
#else
          TYPE ( idll_t ), POINTER :: dll
          TYPE ( idll_node_t ), POINTER :: node_before
#endif
          INTEGER, INTENT ( IN ) :: elmt
          TYPE ( idll_node_t ), POINTER :: node_after
          INTEGER :: ierr
          ALLOCATE ( node_after, stat=ierr )
          IF ( ierr .NE. 0 ) THEN
              idll_insert_after = -2
              RETURN
          END IF
          node_after%ELMT = elmt
          IF ( .NOT. associated ( node_before%NEXT ) ) THEN
              node_before%NEXT => node_after
              node_after%PREV => node_before
              NULLIFY ( node_after%NEXT )
              dll%BACK => node_after
          ELSE
              node_after%PREV => node_before
              node_after%NEXT => node_before%NEXT
              node_before%NEXT => node_after
              node_after%NEXT%PREV => node_after
          END IF
          idll_insert_after = 0
      END FUNCTION idll_insert_after
      FUNCTION idll_lookup (DLL, POS, ELMT)
          INTEGER :: idll_lookup
#if defined(mumps_f2003)
          TYPE ( idll_t ), POINTER, INTENT ( INOUT ) :: dll
#else
          TYPE ( idll_t ), POINTER :: dll
#endif
          INTEGER, INTENT ( IN ) :: pos
          INTEGER, INTENT ( OUT ) :: elmt
          TYPE ( idll_node_t ), POINTER :: aux
          INTEGER :: cpt
          IF ( .NOT. associated ( dll ) ) THEN
              idll_lookup = -1
              RETURN
          END IF
          IF ( pos .LE. 0 ) THEN
              idll_lookup = -4
              RETURN
          END IF
          cpt = 1
          aux => dll%FRONT
          DO WHILE ( ( cpt .LT. pos ) .AND. ( associated ( aux ) ) )
              cpt = cpt + 1
              aux => aux%NEXT
          END DO
          IF ( .NOT. associated ( aux ) ) THEN
              idll_lookup = -3
              RETURN
          END IF
          elmt = aux%ELMT
          idll_lookup = 0
      END FUNCTION idll_lookup
      FUNCTION idll_remove_pos(DLL, POS, ELMT)
          INTEGER :: idll_remove_pos
#if defined(mumps_f2003)
          TYPE ( idll_t ), POINTER, INTENT ( INOUT ) :: dll
#else
          TYPE ( idll_t ), POINTER :: dll
#endif
          INTEGER, INTENT ( IN ) :: pos
          INTEGER, INTENT ( OUT ) :: elmt
          TYPE ( idll_node_t ), POINTER :: aux
          INTEGER :: cpt
          IF ( .NOT. associated ( dll ) ) THEN
              idll_remove_pos = -1
              RETURN
          END IF
          cpt = 1
          aux => dll%FRONT
          DO WHILE ( ( associated ( aux ) ) .AND.
     &               ( cpt .LT. pos ) )
              cpt = cpt + 1
              aux => aux%NEXT
          END DO
          IF ( associated ( aux ) ) THEN
              IF ( .NOT. associated ( aux%PREV ) ) THEN
                  IF ( .NOT. associated ( aux%NEXT ) ) THEN
                      NULLIFY ( dll%FRONT )
                      NULLIFY ( dll%BACK )
                  ELSE
                      NULLIFY ( aux%NEXT%PREV )
                      dll%FRONT => aux%NEXT
                  END IF
              ELSE
                  IF ( .NOT. associated ( aux%NEXT ) ) THEN
                      NULLIFY ( aux%PREV%NEXT )
                      dll%BACK => aux%PREV
                  ELSE
                      aux%PREV%NEXT => aux%NEXT
                      aux%NEXT%PREV => aux%PREV
                  END IF
              END IF
              elmt = aux%ELMT
              DEALLOCATE ( aux )
          ELSE
              idll_remove_pos = -3
              RETURN
          END IF
          idll_remove_pos = 0
      END FUNCTION idll_remove_pos
      FUNCTION idll_remove_elmt(DLL, ELMT, POS)
          INTEGER :: idll_remove_elmt
#if defined(mumps_f2003)
          TYPE ( idll_t ), POINTER, INTENT ( INOUT ) :: dll
#else
          TYPE ( idll_t ), POINTER :: dll
#endif
          INTEGER, INTENT ( IN ) :: elmt
          INTEGER, INTENT ( OUT ) :: pos
          TYPE ( idll_node_t ), POINTER :: aux
          INTEGER :: cpt
          IF ( .NOT. associated ( dll ) ) THEN
              idll_remove_elmt = -1
              RETURN
          END IF
          cpt = 1
          aux => dll%FRONT
          DO WHILE ( ( associated ( aux ) ) .AND.
     &               ( aux%ELMT .NE. elmt ) )
              cpt = cpt + 1
              aux => aux%NEXT
          END DO
          IF ( associated ( aux ) ) THEN
              IF ( .NOT. associated ( aux%PREV ) ) THEN
                  IF ( .NOT. associated ( aux%NEXT ) ) THEN
                      NULLIFY ( dll%FRONT )
                      NULLIFY ( dll%BACK )
                  ELSE
                      NULLIFY ( aux%NEXT%PREV )
                      dll%FRONT => aux%NEXT
                  END IF
              ELSE
                  IF ( .NOT. associated ( aux%NEXT ) ) THEN
                      NULLIFY ( aux%PREV%NEXT )
                      dll%BACK => aux%PREV
                  ELSE
                      aux%PREV%NEXT => aux%NEXT
                      aux%NEXT%PREV => aux%PREV
                  END IF
              END IF
              pos = cpt
              DEALLOCATE ( aux )
          ELSE
              idll_remove_elmt = -3
              RETURN
          END IF
          idll_remove_elmt = 0
      END FUNCTION idll_remove_elmt
      FUNCTION idll_length(DLL)
          INTEGER :: IDLL_LENGTH
#if defined(mumps_f2003)
          TYPE ( idll_t ), POINTER, INTENT ( IN ) :: DLL
#else
          TYPE ( idll_t ), POINTER :: dll
#endif
          INTEGER :: length
          TYPE ( idll_node_t ), POINTER :: aux
          length = 0
          IF ( .NOT. associated ( dll ) ) THEN
              idll_length = -1
              RETURN
          END IF
          aux => dll%FRONT
          DO WHILE ( associated ( aux ) )
              length = length + 1
              aux => aux%NEXT
          END DO
          idll_length = length
      END FUNCTION idll_length
      FUNCTION idll_iterator_begin(DLL, PTR)
          INTEGER :: idll_iterator_begin
#if defined(mumps_f2003)
          TYPE ( idll_t ), POINTER, INTENT ( IN ) :: dll
          TYPE ( idll_node_t ), POINTER, INTENT ( OUT ) :: ptr
#else
          TYPE ( idll_t ), POINTER  :: dll
          TYPE ( IDLL_NODE_T ), POINTER :: ptr
#endif
          IF ( .NOT. associated ( dll ) ) THEN
              idll_iterator_begin = -1
              RETURN
          END IF
          ptr => dll%FRONT
          idll_iterator_begin = 0
      END FUNCTION idll_iterator_begin
      FUNCTION idll_iterator_end(DLL, PTR)
          INTEGER :: idll_iterator_end
#if defined(mumps_f2003)
          TYPE ( idll_t ), POINTER, INTENT ( IN ) :: dll
          TYPE ( idll_node_t ), POINTER, INTENT ( OUT ) :: ptr
#else
          TYPE ( idll_t ), POINTER :: dll
          TYPE ( idll_node_t ), POINTER :: ptr
#endif
          IF ( .NOT. associated ( dll ) ) THEN
              idll_iterator_end = -1
              RETURN
          END IF
          ptr => dll%BACK
          idll_iterator_end = 0
      END FUNCTION idll_iterator_end
      FUNCTION idll_is_empty(DLL)
          LOGICAL :: idll_is_empty
#if defined(mumps_f2003)
          TYPE ( idll_t ), POINTER, INTENT ( IN ) :: dll
#else
          TYPE ( idll_t ), POINTER :: dll
#endif
          idll_is_empty = ( associated ( dll%FRONT ) )
      END FUNCTION idll_is_empty
      FUNCTION idll_2_array(DLL, ARRAY, LENGTH)
          INTEGER :: idll_2_array
#if defined(mumps_f2003)
          TYPE ( idll_t ), POINTER, INTENT ( IN ) :: dll
          INTEGER, POINTER, DIMENSION (:), INTENT ( OUT ) :: array
#else
          TYPE ( idll_t ), POINTER :: dll
          INTEGER, POINTER, DIMENSION (:) :: array
#endif
          INTEGER, INTENT ( OUT ) :: length
          TYPE ( idll_node_t ), POINTER :: AUX
          INTEGER :: i, ierr
          IF ( .NOT. associated ( dll ) ) THEN
              idll_2_array = -1
              RETURN
          END IF
          length = idll_length(dll)
          ALLOCATE ( array( max(1,length) ), stat=ierr )
          IF ( ierr .NE. 0 ) THEN
              idll_2_array = -2
              RETURN
          END IF
          i = 1
          aux => dll%FRONT
          DO WHILE ( associated ( aux ) )
              array( i ) = aux%ELMT
              i = i + 1
              aux => aux%NEXT
          END DO
          idll_2_array = 0
      END FUNCTION idll_2_array
      END MODULE mumps_idll
      MODULE mumps_ddll
      IMPLICIT NONE
      TYPE ddll_node_t
          TYPE ( ddll_node_t ), POINTER :: NEXT, prev
          DOUBLE PRECISION :: elmt
      END TYPE ddll_node_t
      TYPE ddll_t
          TYPE ( ddll_node_t ), POINTER :: front, back
      END TYPE ddll_t
      CONTAINS
      FUNCTION ddll_create(DLL)
          INTEGER :: ddll_create
#if defined(mumps_f2003)
          TYPE ( ddll_t ), POINTER, INTENT ( OUT ) :: dll
#else
          TYPE ( ddll_t ), POINTER :: dll
#endif
          INTEGER ierr
          ALLOCATE ( dll, stat=ierr )
          IF ( ierr .NE. 0 ) THEN
              ddll_create = -2
              RETURN
          END IF
          NULLIFY ( dll%FRONT )
          NULLIFY ( dll%BACK )
          ddll_create = 0
          RETURN
      END FUNCTION ddll_create
      FUNCTION ddll_destroy(DLL)
          INTEGER :: DDLL_DESTROY
#if defined(mumps_f2003)
          TYPE ( ddll_t ), POINTER, INTENT ( INOUT ) :: dll
#else
          TYPE ( ddll_t ), POINTER :: dll
#endif
          TYPE ( ddll_node_t ), POINTER :: aux
          IF ( .NOT. associated ( dll ) ) THEN
              ddll_destroy = -1
              RETURN
          END IF
          DO WHILE ( associated ( dll%FRONT ) )
              aux => dll%FRONT
              dll%FRONT => dll%FRONT%NEXT
              DEALLOCATE( aux )
          END DO
          DEALLOCATE( dll )
          ddll_destroy = 0
      END FUNCTION ddll_destroy
      FUNCTION ddll_push_front(DLL, ELMT)
          INTEGER :: ddll_push_front
#if defined(mumps_f2003)
          TYPE ( ddll_t ), POINTER, INTENT ( INOUT ) :: dll
#else
          TYPE ( ddll_t ), POINTER :: dll
#endif
          DOUBLE PRECISION, INTENT ( IN ) :: elmt
          TYPE ( ddll_node_t ), POINTER :: node
          INTEGER ierr
          IF ( .NOT. associated ( dll ) ) THEN
              ddll_push_front = -1
              RETURN
          END IF
          ALLOCATE( node, stat=ierr )
          IF ( ierr .NE. 0 ) THEN
              ddll_push_front = -2
              RETURN
          END IF
          node%ELMT = elmt
          node%NEXT => dll%FRONT
          NULLIFY ( node%PREV )
          IF ( associated ( dll%FRONT ) ) THEN
              dll%FRONT%PREV => node
          END IF
          dll%FRONT => node
          IF ( .NOT. associated ( dll%BACK ) ) THEN
              dll%BACK => node
          END IF
          ddll_push_front = 0
      END FUNCTION ddll_push_front
      FUNCTION ddll_pop_front(DLL, ELMT)
          INTEGER :: ddll_pop_front
#if defined(mumps_f2003)
          TYPE ( ddll_t ), POINTER, INTENT ( INOUT ) :: dll
#else
          TYPE ( ddll_t ), POINTER :: dll
#endif
          DOUBLE PRECISION, INTENT ( OUT ) :: elmt
          TYPE ( ddll_node_t ), POINTER :: aux
          IF ( .NOT. associated ( dll ) ) THEN
              ddll_pop_front = -1
              RETURN
          END IF
          IF ( .NOT. associated ( dll%FRONT ) ) THEN
              ddll_pop_front = -3
              RETURN
          END IF
          elmt = dll%FRONT%ELMT
          aux => dll%FRONT
          dll%FRONT => dll%FRONT%NEXT
          IF ( associated ( dll%FRONT ) ) THEN
              NULLIFY ( dll%FRONT%PREV )
          END IF
          IF ( associated ( dll%BACK, aux ) ) THEN
              NULLIFY ( dll%BACK )
          END IF
          DEALLOCATE ( aux )
          ddll_pop_front = 0
      END FUNCTION ddll_pop_front
      FUNCTION ddll_push_back(DLL, ELMT)
          INTEGER :: ddll_push_back
#if defined(mumps_f2003)
          TYPE ( ddll_t ), POINTER, INTENT ( INOUT ) :: dll
#else
          TYPE ( ddll_t ), POINTER :: DLL
#endif
          DOUBLE PRECISION, INTENT ( IN ) :: elmt
          TYPE ( ddll_node_t ), POINTER :: node
          INTEGER ierr
          IF ( .NOT. associated ( dll ) ) THEN
              ddll_push_back = -1
              RETURN
          END IF
          ALLOCATE( node, stat=ierr )
          IF ( ierr .NE. 0 ) THEN
              ddll_push_back = -2
              RETURN
          END IF
          node%ELMT = elmt
          NULLIFY ( node%NEXT )
          node%PREV => dll%BACK
          IF ( associated ( dll%BACK ) ) THEN
              dll%BACK%NEXT => node
          END IF
          dll%BACK => node
          IF ( .NOT. associated ( dll%FRONT ) ) THEN
              dll%FRONT => node
          END IF
          ddll_push_back = 0
      END FUNCTION ddll_push_back
      FUNCTION ddll_pop_back(DLL, ELMT)
          INTEGER :: ddll_pop_back
#if defined(mumps_f2003)
          TYPE ( ddll_t ), POINTER, INTENT ( INOUT ) :: dll
#else
          TYPE ( ddll_t ), POINTER :: dll
#endif
          DOUBLE PRECISION, INTENT ( OUT ) :: elmt
          TYPE ( ddll_node_t ), POINTER :: aux
          IF ( .NOT. associated ( dll ) ) THEN
              ddll_pop_back = -1
              RETURN
          END IF
          IF ( .NOT. associated ( dll%BACK ) ) THEN
              ddll_pop_back = -3
              RETURN
          END IF
          elmt = dll%BACK%ELMT
          aux => dll%BACK
          dll%BACK => dll%BACK%PREV
          IF ( associated ( dll%BACK ) ) THEN
              NULLIFY ( dll%BACK%NEXT )
          END IF
          IF ( associated ( dll%FRONT, aux ) ) THEN
              NULLIFY ( dll%FRONT )
          END IF
          DEALLOCATE ( aux )
          ddll_pop_back = 0
      END FUNCTION ddll_pop_back
      FUNCTION ddll_insert(DLL, POS, ELMT)
          INTEGER :: ddll_insert
#if defined(mumps_f2003)
          TYPE ( ddll_t ), POINTER, INTENT ( INOUT ) :: dll
#else
          TYPE ( ddll_t ), POINTER :: dll
#endif
          INTEGER, INTENT ( IN ) :: pos
          DOUBLE PRECISION , INTENT ( IN ) :: elmt
          TYPE ( ddll_node_t ), POINTER :: node
          TYPE ( ddll_node_t ), POINTER :: new_ptr, old_ptr
          INTEGER :: ierr, cpt
          IF ( .NOT. associated ( dll ) ) THEN
              ddll_insert = -1
              RETURN
          END IF
          IF ( pos .LE. 0 ) THEN
              ddll_insert = -4
              RETURN
          END IF
          cpt = 1
          new_ptr => dll%FRONT
          NULLIFY ( old_ptr )
          DO WHILE ( ( cpt .LT. pos ) .AND.
     &               ( associated ( new_ptr ) ) )
              old_ptr => new_ptr
              new_ptr => new_ptr%NEXT
              cpt = cpt + 1
          END DO
          ALLOCATE ( node, stat=ierr )
          IF ( ierr .NE. 0 ) THEN
              ddll_insert = -2
              RETURN
          END IF
          node%ELMT = elmt
          IF ( .NOT. associated ( old_ptr ) ) THEN
              IF ( .NOT. associated ( new_ptr ) ) THEN
                  NULLIFY ( node%PREV )
                  NULLIFY ( node%NEXT )
                  dll%FRONT => node
                  dll%BACK => node
              ELSE
                  NULLIFY ( node%PREV )
                  node%NEXT => new_ptr
                  new_ptr%PREV => node
                  dll%FRONT => node
              END IF
          ELSE
              IF ( .NOT. associated ( new_ptr ) ) THEN
                  node%PREV => old_ptr
                  NULLIFY ( node%NEXT )
                  old_ptr%NEXT => node
                  dll%BACK => node
              ELSE
                  node%PREV => old_ptr
                  node%NEXT => new_ptr
                  old_ptr%NEXT => node
                  new_ptr%PREV => node
              END IF
          END IF
          ddll_insert = 0
      END FUNCTION ddll_insert
      FUNCTION ddll_insert_before(DLL, NODE_AFTER, ELMT)
          INTEGER :: ddll_insert_before
#if defined(mumps_f2003)
          TYPE ( ddll_t ), POINTER, INTENT ( INOUT ) :: dll
          TYPE ( ddll_node_t ), POINTER, INTENT ( IN ) :: node_after
#else
          TYPE ( ddll_t ), POINTER :: dll
          TYPE ( ddll_node_t ), POINTER :: node_after
#endif
          DOUBLE PRECISION, INTENT ( IN ) :: elmt
          TYPE ( ddll_node_t ), POINTER :: node_before
          INTEGER :: ierr
          ALLOCATE ( node_before, stat=ierr )
          IF ( ierr .NE. 0 ) THEN
              ddll_insert_before = -2
              RETURN
          END IF
          node_before%ELMT = elmt
          IF ( .NOT. associated ( node_after%PREV ) ) THEN
              node_after%PREV => node_before
              node_before%NEXT => node_after
              NULLIFY ( node_before%PREV )
              dll%FRONT => node_before
          ELSE
              node_before%NEXT => node_after
              node_before%PREV => node_after%PREV
              node_after%PREV => node_before
              node_before%PREV%NEXT => node_before
          END IF
          ddll_insert_before = 0
      END FUNCTION ddll_insert_before
      FUNCTION ddll_insert_after(DLL, NODE_BEFORE, ELMT)
          INTEGER :: ddll_insert_after
#if defined(mumps_f2003)
          TYPE ( ddll_t ), POINTER, INTENT ( INOUT ) :: dll
          TYPE ( ddll_node_t ), POINTER, INTENT ( IN ) :: node_before
#else
          TYPE ( ddll_t ), POINTER :: dll
          TYPE ( ddll_node_t ), POINTER :: node_before
#endif
          DOUBLE PRECISION, INTENT ( IN ) :: elmt
          TYPE ( ddll_node_t ), POINTER :: node_after
          INTEGER :: ierr
          ALLOCATE ( node_after, stat=ierr )
          IF ( ierr .NE. 0 ) THEN
              ddll_insert_after = -2
              RETURN
          END IF
          node_after%ELMT = elmt
          IF ( .NOT. associated ( node_before%NEXT ) ) THEN
              node_before%NEXT => node_after
              node_after%PREV => node_before
              NULLIFY ( node_after%NEXT )
              dll%BACK => node_after
          ELSE
              node_after%PREV => node_before
              node_after%NEXT => node_before%NEXT
              node_before%NEXT => node_after
              node_after%NEXT%PREV => node_after
          END IF
          ddll_insert_after = 0
      END FUNCTION ddll_insert_after
      FUNCTION ddll_lookup (DLL, POS, ELMT)
          INTEGER :: ddll_lookup
#if defined(mumps_f2003)
          TYPE ( ddll_t ), POINTER, INTENT ( INOUT ) :: dll
#else
          TYPE ( DDLL_T ), POINTER :: dll
#endif
          INTEGER, INTENT ( IN ) :: pos
          DOUBLE PRECISION, INTENT ( OUT ) :: elmt
          TYPE ( ddll_node_t ), POINTER :: aux
          INTEGER :: cpt
          IF ( .NOT. associated ( dll ) ) THEN
              ddll_lookup = -1
              RETURN
          END IF
          IF ( pos .LE. 0 ) THEN
              ddll_lookup = -4
              RETURN
          END IF
          cpt = 1
          aux => dll%FRONT
          DO WHILE ( ( cpt .LT. pos ) .AND. ( associated ( aux ) ) )
              cpt = cpt + 1
              aux => aux%NEXT
          END DO
          IF ( .NOT. associated ( aux ) ) THEN
              ddll_lookup = -3
              RETURN
          END IF
          elmt = aux%ELMT
          ddll_lookup = 0
      END FUNCTION ddll_lookup
      FUNCTION ddll_remove_pos(DLL, POS, ELMT)
          INTEGER :: ddll_remove_pos
#if defined(mumps_f2003)
          TYPE ( ddll_t ), POINTER, INTENT ( INOUT ) :: dll
#else
          TYPE ( DDLL_T ), POINTER :: dll
#endif
          INTEGER, INTENT ( IN ) :: pos
          DOUBLE PRECISION, INTENT ( OUT ) :: elmt
          TYPE ( ddll_node_t ), POINTER :: aux
          INTEGER :: cpt
          IF ( .NOT. associated ( dll ) ) THEN
              ddll_remove_pos = -1
              RETURN
          END IF
          cpt = 1
          aux => dll%FRONT
          DO WHILE ( ( associated ( aux ) ) .AND.
     &               ( cpt .LT. pos ) )
              cpt = cpt + 1
              aux => aux%NEXT
          END DO
          IF ( associated ( aux ) ) THEN
              IF ( .NOT. associated ( aux%PREV ) ) THEN
                  IF ( .NOT. associated ( aux%NEXT ) ) THEN
                      NULLIFY ( dll%FRONT )
                      NULLIFY ( dll%BACK )
                  ELSE
                      NULLIFY ( aux%NEXT%PREV )
                      dll%FRONT => aux%NEXT
                  END IF
              ELSE
                  IF ( .NOT. associated ( aux%NEXT ) ) THEN
                      NULLIFY ( aux%PREV%NEXT )
                      dll%BACK => aux%PREV
                  ELSE
                      aux%PREV%NEXT => aux%NEXT
                      aux%NEXT%PREV => aux%PREV
                  END IF
              END IF
              elmt = aux%ELMT
              DEALLOCATE ( aux )
          ELSE
              ddll_remove_pos = -3
              RETURN
          END IF
          ddll_remove_pos = 0
      END FUNCTION ddll_remove_pos
      FUNCTION ddll_remove_elmt(DLL, ELMT, POS)
          INTEGER :: ddll_remove_elmt
#if defined(mumps_f2003)
          TYPE ( ddll_t ), POINTER, INTENT ( INOUT ) :: dll
#else
          TYPE ( ddll_t ), POINTER :: dll
#endif
          DOUBLE PRECISION, INTENT ( IN ) :: elmt
          INTEGER, INTENT ( OUT ) :: POS
          TYPE ( ddll_node_t ), POINTER :: aux
          INTEGER :: cpt
          IF ( .NOT. associated ( dll ) ) THEN
              ddll_remove_elmt = -1
              RETURN
          END IF
          cpt = 1
          aux => dll%FRONT
          DO WHILE ( ( associated ( aux ) ) .AND.
     &               ( aux%ELMT .NE. elmt ) )
              cpt = cpt + 1
              aux => aux%NEXT
          END DO
          IF ( associated ( aux ) ) THEN
              IF ( .NOT. associated ( aux%PREV ) ) THEN
                  IF ( .NOT. associated ( aux%NEXT ) ) THEN
                      NULLIFY ( dll%FRONT )
                      NULLIFY ( dll%BACK )
                  ELSE
                      NULLIFY ( aux%NEXT%PREV )
                      dll%FRONT => aux%NEXT
                  END IF
              ELSE
                  IF ( .NOT. associated ( aux%NEXT ) ) THEN
                      NULLIFY ( aux%PREV%NEXT )
                      dll%BACK => aux%PREV
                  ELSE
                      aux%PREV%NEXT => aux%NEXT
                      aux%NEXT%PREV => aux%PREV
                  END IF
              END IF
              pos = cpt
              DEALLOCATE ( aux )
          ELSE
              ddll_remove_elmt = -3
              RETURN
          END IF
          ddll_remove_elmt = 0
      END FUNCTION ddll_remove_elmt
      FUNCTION ddll_length(DLL)
          INTEGER :: ddll_length
#if defined(mumps_f2003)
          TYPE ( ddll_t ), POINTER, INTENT ( IN ) :: dll
#else
          TYPE ( ddll_t ), POINTER :: dll
#endif
          INTEGER :: length
          TYPE ( ddll_node_t ), POINTER :: aux
          IF ( .NOT. associated ( dll ) ) THEN
              ddll_length = -1
              RETURN
          END IF
          length = 0
          aux => dll%FRONT
          DO WHILE ( associated ( aux ) )
              length = length + 1
              aux => aux%NEXT
          END DO
          ddll_length = length
      END FUNCTION ddll_length
      FUNCTION ddll_iterator_begin(DLL, PTR)
          INTEGER :: ddll_iterator_begin
#if defined(mumps_f2003)
          TYPE ( ddll_t ), POINTER, INTENT ( IN ) :: dll
          TYPE ( ddll_node_t ), POINTER, INTENT ( OUT ) :: ptr
#else
          TYPE ( ddll_t ), POINTER :: dll
          TYPE ( ddll_node_t ), POINTER :: ptr
#endif
          IF ( .NOT. associated ( dll ) ) THEN
              ddll_iterator_begin = -1
              RETURN
          END IF
          ptr => dll%FRONT
          ddll_iterator_begin = 0
      END FUNCTION ddll_iterator_begin
      FUNCTION ddll_iterator_end(DLL, PTR)
          INTEGER :: ddll_iterator_end
#if defined(mumps_f2003)
          TYPE ( ddll_t ), POINTER, INTENT ( IN ) :: dll
          TYPE ( ddll_node_t ), POINTER, INTENT ( OUT ) :: ptr
#else
          TYPE ( ddll_t ), POINTER :: dll
          TYPE ( ddll_node_t ), POINTER :: ptr
#endif
          IF ( .NOT. associated ( dll ) ) THEN
              ddll_iterator_end = -1
              RETURN
          END IF
          ptr => dll%BACK
          ddll_iterator_end = 0
      END FUNCTION ddll_iterator_end
      FUNCTION ddll_is_empty(DLL)
          LOGICAL :: ddll_is_empty
#if defined(mumps_f2003)
          TYPE ( ddll_t ), POINTER, INTENT ( IN ) :: dll
#else
          TYPE ( ddll_t ), POINTER :: dll
#endif
          ddll_is_empty = ( associated ( dll%FRONT ) )
      END FUNCTION ddll_is_empty
      FUNCTION ddll_2_array(DLL, ARRAY, LENGTH)
          INTEGER :: ddll_2_array
#if defined(mumps_f2003)
          TYPE ( ddll_t ), POINTER, INTENT ( IN ) :: dll
          DOUBLE PRECISION, POINTER, DIMENSION(:), INTENT(OUT) :: array
#else
          TYPE ( ddll_t ), POINTER :: dll
          DOUBLE PRECISION, POINTER, DIMENSION(:) :: array
#endif
          INTEGER, INTENT ( OUT ) :: length
          TYPE ( ddll_node_t ), POINTER :: aux
          INTEGER :: i, ierr
          IF ( .NOT. associated ( dll ) ) THEN
              ddll_2_array = -1
              RETURN
          END IF
          length = ddll_length(dll)
          ALLOCATE ( array( max(1,length) ), stat=ierr )
          IF ( ierr .NE. 0 ) THEN
              ddll_2_array = -2
              RETURN
          END IF
          i = 1
          aux => dll%FRONT
          DO WHILE ( associated ( aux ) )
              array( i ) = aux%ELMT
              i = i + 1
              aux => aux%NEXT
          END DO
          ddll_2_array = 0
      END FUNCTION ddll_2_array
      END MODULE mumps_ddll