anchor.diff:    !---------------------------------------------------------------------------------------------------------------------------------
     endfunction str_bol
   
  -  pure function str_a_R16P(n, no_sign, delimiters) result(str)
  +  pure function str_a_R16P(n, no_sign, delimiters, compact) result(str)
     !---------------------------------------------------------------------------------------------------------------------------------
     !< Converting real array to string.
     !---------------------------------------------------------------------------------------------------------------------------------
     real(R16P),   intent(in)           :: n(:)            !< Real array to be converted.
     logical,      intent(in), optional :: no_sign         !< Flag for leaving out the sign.
     character(*), intent(in), optional :: delimiters(1:2) !< Eventual delimiters of array values.
  +  logical,      intent(in), optional :: compact         !< Flag for *compacting* string encoding.
     character(len=:), allocatable      :: str             !< Returned string containing input number.
     character(DR16P)                   :: strn            !< String containing of element of input array number.
     integer                            :: i               !< Counter.
     !---------------------------------------------------------------------------------------------------------------------------------
   
     !---------------------------------------------------------------------------------------------------------------------------------
  -  if (present(no_sign)) then
  -    str = ''
  -    do i=1,size(n)
  -      strn = str_R16P(no_sign=no_sign, n=n(i))
  -      str = str//','//trim(strn)
  -    enddo
  -  else
  -    str = ''
  -    do i=1,size(n)
  -      strn = str_R16P(n=n(i))
  -      str = str//','//trim(strn)
  -    enddo
  -  endif
  +  str = ''
  +  do i=1,size(n)
  +    strn = str_R16P(no_sign=no_sign, compact=compact, n=n(i))
  +    str = str//','//trim(strn)
  +  enddo
     str = trim(str(2:))
     if (present(delimiters)) str = delimiters(1)//str//delimiters(2)
     return
     !---------------------------------------------------------------------------------------------------------------------------------
     endfunction str_a_R16P
   
  -  pure function str_a_R8P(n, no_sign, delimiters) result(str)
  +  pure function str_a_R8P(n, no_sign, delimiters, compact) result(str)
     !---------------------------------------------------------------------------------------------------------------------------------
     !< Convert real array to string.
     !---------------------------------------------------------------------------------------------------------------------------------
     real(R8P),    intent(in)           :: n(:)            !< Real array to be converted.
     logical,      intent(in), optional :: no_sign         !< Flag for leaving out the sign.
     character(*), intent(in), optional :: delimiters(1:2) !< Eventual delimiters of array values.
  +  logical,      intent(in), optional :: compact         !< Flag for *compacting* string encoding.
     character(len=:), allocatable      :: str             !< Returned string containing input number.
     character(DR8P)                    :: strn            !< String containing of element of input array number.
     integer                            :: i               !< Counter.
     !---------------------------------------------------------------------------------------------------------------------------------
   
     !---------------------------------------------------------------------------------------------------------------------------------
  -  if (present(no_sign)) then
  -    str = ''
  -    do i=1,size(n)
  -      strn = str_R8P(no_sign=no_sign, n=n(i))
  -      str = str//','//trim(strn)
  -    enddo
  -  else
  -    str = ''
  -    do i=1,size(n)
  -      strn = str_R8P(n=n(i))
  -      str = str//','//trim(strn)
  -    enddo
  -  endif
  +  str = ''
  +  do i=1,size(n)
  +    strn = str_R8P(no_sign=no_sign, compact=compact, n=n(i))
  +    str = str//','//trim(strn)
  +  enddo
     str = trim(str(2:))
     if (present(delimiters)) str = delimiters(1)//str//delimiters(2)
     return
     !---------------------------------------------------------------------------------------------------------------------------------
     endfunction str_a_R8P
   
  -  pure function str_a_R4P(n, no_sign, delimiters) result(str)
  +  pure function str_a_R4P(n, no_sign, delimiters, compact) result(str)
     !---------------------------------------------------------------------------------------------------------------------------------
     !< Convert real array to string.
     !---------------------------------------------------------------------------------------------------------------------------------
     real(R4P),    intent(in)           :: n(:)            !< Real array to be converted.
     logical,      intent(in), optional :: no_sign         !< Flag for leaving out the sign.
     character(*), intent(in), optional :: delimiters(1:2) !< Eventual delimiters of array values.
  +  logical,      intent(in), optional :: compact         !< Flag for *compacting* string encoding.
     character(len=:), allocatable      :: str             !< Returned string containing input number.
     character(DR4P)                    :: strn            !< String containing of element of input array number.
     integer                            :: i               !< Counter.
     !---------------------------------------------------------------------------------------------------------------------------------
   
     !---------------------------------------------------------------------------------------------------------------------------------
  -  if (present(no_sign)) then
  -    str = ''
  -    do i=1,size(n)
  -      strn = str_R4P(no_sign=no_sign, n=n(i))
  -      str = str//','//trim(strn)
  -    enddo
  -  else
  -    str = ''
  -    do i=1,size(n)
  -      strn = str_R4P(n=n(i))
  -      str = str//','//trim(strn)
  -    enddo
  -  endif
  +  str = ''
  +  do i=1,size(n)
  +    strn = str_R4P(no_sign=no_sign, compact=compact, n=n(i))
  +    str = str//','//trim(strn)
  +  enddo
     str = trim(str(2:))
     if (present(delimiters)) str = delimiters(1)//str//delimiters(2)
     return
  
positive.code:   write(str, FR16P) n               ! Casting of n to string.
    if (n>0._R16P) str(1:1)='+'       ! Prefixing plus if n>0.
    if (present(no_sign)) str=str(2:) ! Leaving out the sign.
    return
    !---------------------------------------------------------------------------------------------------------------------------------
    endfunction str_R16P
  
    elemental function str_R8P(n, no_sign) result(str)
    !---------------------------------------------------------------------------------------------------------------------------------
    !< Convert real to string.
    !---------------------------------------------------------------------------------------------------------------------------------
    real(R8P), intent(in)           :: n       !< Real to be converted.
    logical,   intent(in), optional :: no_sign !< Flag for leaving out the sign.
    character(DR8P)                 :: str     !< Returned string containing input number.
    !---------------------------------------------------------------------------------------------------------------------------------
  
  
negative.code:   !---------------------------------------------------------------------------------------------------------------------------------
    endfunction strf_I1P
  
    elemental function str_R16P(n, no_sign, compact) result(str)
    !---------------------------------------------------------------------------------------------------------------------------------
    !< Convert real to string.
    !---------------------------------------------------------------------------------------------------------------------------------
    real(R16P), intent(in)           :: n       !< Real to be converted.
    logical,    intent(in), optional :: no_sign !< Flag for leaving out the sign.
    logical,    intent(in), optional :: compact !< Flag for *compacting* string encoding.
    character(DR16P)                 :: str     !< Returned string containing input number.
    !---------------------------------------------------------------------------------------------------------------------------------
  
  