IR_Precision.f90

Go to the documentation of this file.

module ir_precision
!-----------------------------------------------------------------------------------------------------------------------------------
use, intrinsic:: iso_fortran_env, only: stdout => output_unit, stderr => error_unit ! Standard output/error logical units.
!-----------------------------------------------------------------------------------------------------------------------------------

!-----------------------------------------------------------------------------------------------------------------------------------
implicit none
private
public:: endianl,endianb,endian
public:: r16p, fr16p, dr16p, minr16p, maxr16p, bir16p, byr16p, smallr16p, zeror16
public:: r8p,  fr8p,  dr8p,  minr8p,  maxr8p,  bir8p,  byr8p,  smallr8p,  zeror8
public:: r4p,  fr4p,  dr4p,  minr4p,  maxr4p,  bir4p,  byr4p,  smallr4p,  zeror4
public:: r_p,  fr_p,  dr_p,  minr_p,  maxr_p,  bir_p,  byr_p,  smallr_p,  zero
public:: i8p,  fi8p,  di8p,  mini8p,  maxi8p,  bii8p,  byi8p
public:: i4p,  fi4p,  di4p,  mini4p,  maxi4p,  bii4p,  byi4p
public:: i2p,  fi2p,  di2p,  mini2p,  maxi2p,  bii2p,  byi2p
public:: i1p,  fi1p,  di1p,  mini1p,  maxi1p,  bii1p,  byi1p
public:: i_p,  fi_p,  di_p,  mini_p,  maxi_p,  bii_p,  byi_p
public:: nrknd, rpl, frl
public:: niknd, ril, fil
public:: check_endian
public:: bit_size,byte_size
public:: str, strz, cton, bstr, bcton
public:: ir_initialized,ir_init
public:: ir_print
!-----------------------------------------------------------------------------------------------------------------------------------

!-----------------------------------------------------------------------------------------------------------------------------------
logical:: ir_initialized = .false.
! Bit ordering of the running architecture:
integer, parameter:: endianl = 1
integer, parameter:: endianb = 0
integer::            endian  = endianl

! The following are the portable kind parameters available.
! Real precision definitions:
#ifdef r16p
integer, parameter:: r16p = selected_real_kind(33,4931)
#else
integer, parameter:: r16p = selected_real_kind(15,307)
#endif
integer, parameter:: r8p  = selected_real_kind(15,307)
integer, parameter:: r4p  = selected_real_kind(6,37)
integer, parameter:: r_p  = r8p
! Integer precision definitions:
integer, parameter:: i8p  = selected_int_kind(18)
integer, parameter:: i4p  = selected_int_kind(9)
integer, parameter:: i2p  = selected_int_kind(4)
integer, parameter:: i1p  = selected_int_kind(2)
integer, parameter:: i_p  = i4p

! Format parameters useful for writing in a well-ascii-format numeric variables.
! Real output formats:
character(10), parameter:: fr16p = '(E42.33E4)'
character(10), parameter:: fr8p  = '(E23.15E3)'
character(9),  parameter:: fr4p  = '(E13.6E2)'
character(10), parameter:: fr_p  = fr8p
! Real number of digits of output formats:
integer, parameter:: dr16p = 42
integer, parameter:: dr8p  = 23
integer, parameter:: dr4p  = 13
integer, parameter:: dr_p  = dr8p
! Integer output formats:
character(5), parameter:: fi8p   = '(I20)'
character(8), parameter:: fi8pzp = '(I20.19)'
character(5), parameter:: fi4p   = '(I11)'
character(8), parameter:: fi4pzp = '(I11.10)'
character(4), parameter:: fi2p   = '(I6)'
character(6), parameter:: fi2pzp = '(I6.5)'
character(4), parameter:: fi1p   = '(I4)'
character(6), parameter:: fi1pzp = '(I4.3)'
character(5), parameter:: fi_p   = fi4p
character(8), parameter:: fi_pzp = fi4pzp
! Integer number of digits of output formats:
integer, parameter:: di8p = 20
integer, parameter:: di4p = 11
integer, parameter:: di2p = 6
integer, parameter:: di1p = 4
integer, parameter:: di_p = di4p
! List of kinds
integer,       parameter:: nrknd=4
integer,       parameter:: RPl(1:NRknd)=[R16P,R8P,R4P,R_P]
character(10), parameter:: FRl(1:NRknd)=[FR16P,FR8P,FR4P//' ',FR_P]
integer,       parameter:: NIknd=5
integer,       parameter:: RIl(1:NIknd)=[I8P,I4P,I2P,I1P,I_P]
character(5),  parameter:: FIl(1:NIknd)=[FI8P,FI4P,FI2P//' ',FI1P//' ',FI_P]

! Useful parameters for handling numbers ranges.
! Real min and max values:
real(R16P), parameter:: MinR16P = -huge(1._R16P), MaxR16P = huge(1._R16P)
real(R8P),  parameter:: MinR8P  = -huge(1._R8P ), MaxR8P  = huge(1._R8P )
real(R4P),  parameter:: MinR4P  = -huge(1._R4P ), MaxR4P  = huge(1._R4P )
real(R_P),  parameter:: MinR_P  = MinR8P,         MaxR_P  = MaxR8P
! Real number of bits/bytes
integer(I2P):: BIR16P, BYR16P
integer(I1P):: BIR8P,  BYR8P
integer(I1P):: BIR4P,  BYR4P
integer(I1P):: BIR_P,  BYR_P
! Real smallest values:
real(R16P), parameter:: smallR16P = tiny(1._R16P)
real(R8P),  parameter:: smallR8P  = tiny(1._R8P )
real(R4P),  parameter:: smallR4P  = tiny(1._R4P )
real(R_P),  parameter:: smallR_P  = smallR8P
! Integer min and max values:
integer(I8P), parameter:: MinI8P = -huge(1_I8P), MaxI8P = huge(1_I8P)
integer(I4P), parameter:: MinI4P = -huge(1_I4P), MaxI4P = huge(1_I4P)
integer(I2P), parameter:: MinI2P = -huge(1_I2P), MaxI2P = huge(1_I2P)
integer(I1P), parameter:: MinI1P = -huge(1_I1P), MaxI1P = huge(1_I1P)
integer(I_P), parameter:: MinI_P = MinI4P,       MaxI_P = MaxI4P
! Integer number of bits/bytes:
integer(I8P), parameter:: BII8P = bit_size(MaxI8P), BYI8P = bit_size(MaxI8P)/8_I8P
integer(I4P), parameter:: BII4P = bit_size(MaxI4P), BYI4P = bit_size(MaxI4P)/8_I4P
integer(I2P), parameter:: BII2P = bit_size(MaxI2P), BYI2P = bit_size(MaxI2P)/8_I2P
integer(I1P), parameter:: BII1P = bit_size(MaxI1P), BYI1P = bit_size(MaxI1P)/8_I1P
integer(I_P), parameter:: BII_P = bit_size(MaxI_P), BYI_P = bit_size(MaxI_P)/8_I_P
! Smallest real representable difference by the running calculator.
#ifdef pgf95
real(R16P), parameter:: ZeroR16 = 0._R16P
real(R8P),  parameter:: ZeroR8  = 0._R8P
real(R4P),  parameter:: ZeroR4  = 0._R4P
#else
real(R16P), parameter:: ZeroR16 = nearest(1._R16P, 1._R16P) - &
                                  nearest(1._R16P,-1._R16P)
real(R8P),  parameter:: ZeroR8  = nearest(1._R8P, 1._R8P) - &
                                  nearest(1._R8P,-1._R8P)
real(R4P),  parameter:: ZeroR4  = nearest(1._R4P, 1._R4P) - &
                                  nearest(1._R4P,-1._R4P)
#endif
real(R_P),  parameter:: Zero    = ZeroR8
!-----------------------------------------------------------------------------------------------------------------------------------

!-----------------------------------------------------------------------------------------------------------------------------------
interface bit_size
  module procedure                &
#ifdef r16p
                   bit_size_r16p, &
#endif
                   bit_size_r8p,  &
                   bit_size_r4p,  &
                   bit_size_chr
endinterface
interface byte_size
  module procedure                 &
                   byte_size_i8p,  &
                   byte_size_i4p,  &
                   byte_size_i2p,  &
                   byte_size_i1p,  &
#ifdef r16p
                   byte_size_r16p, &
#endif
                   byte_size_r8p,  &
                   byte_size_r4p,  &
                   byte_size_chr
endinterface
interface str
  module procedure                    &
#ifdef r16p
                   strf_r16p,str_r16p,&
#endif
                   strf_r8p ,str_r8p, &
                   strf_r4p ,str_r4p, &
                   strf_i8p ,str_i8p, &
                   strf_i4p ,str_i4p, &
                   strf_i2p ,str_i2p, &
                   strf_i1p ,str_i1p
endinterface
interface strz
  module procedure strz_i8p,  &
                   strz_i4p,  &
                   strz_i2p,  &
                   strz_i1p
endinterface
interface cton
  module procedure            &
#ifdef r16p
                   ctor_r16p, &
#endif
                   ctor_r8p,  &
                   ctor_r4p,  &
                   ctoi_i8p,  &
                   ctoi_i4p,  &
                   ctoi_i2p,  &
                   ctoi_i1p
endinterface
interface bstr
  module procedure           &
#ifdef r16p
                   bstr_r16p,&
#endif
                   bstr_r8p, &
                   bstr_r4p, &
                   bstr_i8p, &
                   bstr_i4p, &
                   bstr_i2p, &
                   bstr_i1p
endinterface
interface bcton
  module procedure            &
#ifdef r16p
                   bctor_r16p, &
#endif
                   bctor_r8p,  &
                   bctor_r4p,  &
                   bctoi_i8p,  &
                   bctoi_i4p,  &
                   bctoi_i2p,  &
                   bctoi_i1p
endinterface
!-----------------------------------------------------------------------------------------------------------------------------------
contains
  pure function is_little_endian() result(is_little)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  logical::      is_little
  integer(I1P):: int1(1:4)
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  int1 = transfer(1_i4p,int1)
  is_little = (int1(1)==1_i1p)
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction is_little_endian

  subroutine check_endian()
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  if (is_little_endian()) then
    endian = endianl
  else
    endian = endianb
  endif
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endsubroutine check_endian

  elemental function bit_size_r16p(r) result(bits)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  real(R16P), intent(IN):: r
  integer(I2P)::           bits
  integer(I1P)::           mold(1)
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  bits = size(transfer(r,mold),dim=1,kind=i2p)*8_i2p
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction bit_size_r16p

  elemental function bit_size_r8p(r) result(bits)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  real(R8P), intent(IN):: r
  integer(I1P)::          bits
  integer(I1P)::          mold(1)
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  bits = size(transfer(r,mold),dim=1,kind=i1p)*8_i1p
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction bit_size_r8p

  elemental function bit_size_r4p(r) result(bits)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  real(R4P), intent(IN):: r
  integer(I1P)::          bits
  integer(I1P)::          mold(1)
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  bits = size(transfer(r,mold),dim=1,kind=i1p)*8_i1p
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction bit_size_r4p

  elemental function bit_size_chr(c) result(bits)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  character(*), intent(IN):: c
  integer(I4P)::             bits
  integer(I1P)::             mold(1)
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  bits = size(transfer(c,mold),dim=1,kind=i4p)*8_i4p
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction bit_size_chr

  elemental function byte_size_i8p(i) result(bytes)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  integer(I8P), intent(IN):: i
  integer(I1P)::             bytes
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  bytes = bit_size(i)/8_i1p
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction byte_size_i8p

  elemental function byte_size_i4p(i) result(bytes)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  integer(I4P), intent(IN):: i
  integer(I1P)::             bytes
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  bytes = bit_size(i)/8_i1p
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction byte_size_i4p

  elemental function byte_size_i2p(i) result(bytes)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  integer(I2P), intent(IN):: i
  integer(I1P)::             bytes
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  bytes = bit_size(i)/8_i1p
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction byte_size_i2p

  elemental function byte_size_i1p(i) result(bytes)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  integer(I1P), intent(IN):: i
  integer(I1P)::             bytes
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  bytes = bit_size(i)/8_i1p
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction byte_size_i1p

  elemental function byte_size_r16p(r) result(bytes)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  real(R16P), intent(IN):: r
  integer(I1P)::           bytes
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  bytes = bit_size(r)/8_i1p
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction byte_size_r16p

  elemental function byte_size_r8p(r) result(bytes)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  real(R8P), intent(IN):: r
  integer(I1P)::          bytes
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  bytes = bit_size(r)/8_i1p
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction byte_size_r8p

  elemental function byte_size_r4p(r) result(bytes)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  real(R4P), intent(IN):: r
  integer(I1P)::          bytes
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  bytes = bit_size(r)/8_i1p
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction byte_size_r4p

  elemental function byte_size_chr(c) result(bytes)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  character(*), intent(IN):: c
  integer(I4P)::             bytes
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  bytes = bit_size(c)/8_i4p
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction byte_size_chr

  elemental function strf_r16p(fm,n) result(str)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  character(*), intent(IN):: fm
  real(R16P),   intent(IN):: n
  character(DR16P)::         str
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  write(str,trim(fm)) n ! Casting of n to string.
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction strf_r16p

  elemental function strf_r8p(fm,n) result(str)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  character(*), intent(IN):: fm
  real(R8P),    intent(IN):: n
  character(DR8P)::          str
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  write(str,trim(fm)) n ! Casting of n to string.
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction strf_r8p

  elemental function strf_r4p(fm,n) result(str)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  character(*), intent(IN):: fm
  real(R4P),    intent(IN):: n
  character(DR4P)::          str
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  write(str,trim(fm)) n ! Casting of n to string.
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction strf_r4p

  elemental function strf_i8p(fm,n) result(str)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  character(*), intent(IN):: fm
  integer(I8P), intent(IN):: n
  character(DI8P)::          str
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  write(str,trim(fm)) n ! Casting of n to string.
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction strf_i8p

  elemental function strf_i4p(fm,n) result(str)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  character(*), intent(IN):: fm
  integer(I4P), intent(IN):: n
  character(DI4P)::          str
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  write(str,trim(fm)) n ! Casting of n to string.
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction strf_i4p

  elemental function strf_i2p(fm,n) result(str)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  character(*), intent(IN):: fm
  integer(I2P), intent(IN):: n
  character(DI2P)::          str
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  write(str,trim(fm)) n ! Casting of n to string.
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction strf_i2p

  elemental function strf_i1p(fm,n) result(str)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  character(*), intent(IN):: fm
  integer(I1P), intent(IN):: n
  character(DI1P)::          str
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  write(str,trim(fm)) n ! Casting of n to string.
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction strf_i1p

  elemental function str_r16p(no_sign,n) result(str)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  logical,    intent(IN), optional:: no_sign
  real(R16P), intent(IN)::           n
  character(DR16P)::                 str
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  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(no_sign,n) result(str)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  logical,      intent(IN), optional:: no_sign
  real(R8P),    intent(IN)::           n
  character(DR8P)::                    str
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  write(str,fr8p) n                 ! Casting of n to string.
  if (n>0._r8p) str(1:1)='+'        ! Prefixing plus if n>0.
  if (present(no_sign)) str=str(2:) ! Leaving out the sign.
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction str_r8p

  elemental function str_r4p(no_sign,n) result(str)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  logical,   intent(IN), optional:: no_sign
  real(R4P), intent(IN)::           n
  character(DR4P)::                 str
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  write(str,fr4p) n                 ! Casting of n to string.
  if (n>0._r4p) str(1:1)='+'        ! Prefixing plus if n>0.
  if (present(no_sign)) str=str(2:) ! Leaving out the sign.
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction str_r4p

  elemental function str_i8p(no_sign,n) result(str)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  logical,      intent(IN), optional:: no_sign
  integer(I8P), intent(IN)::           n
  character(DI8P)::                    str
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  write(str,fi8p) n                 ! Casting of n to string.
  str = adjustl(trim(str))          ! Removing white spaces.
  if (n>=0_i8p) str='+'//trim(str)  ! Prefixing plus if n>0.
  if (present(no_sign)) str=str(2:) ! Leaving out the sign.
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction str_i8p

  elemental function str_i4p(no_sign,n) result(str)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  logical,      intent(IN), optional:: no_sign
  integer(I4P), intent(IN)::           n
  character(DI4P)::                    str
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  write(str,fi4p) n                 ! Casting of n to string.
  str = adjustl(trim(str))          ! Removing white spaces.
  if (n>=0_i4p) str='+'//trim(str)  ! Prefixing plus if n>0.
  if (present(no_sign)) str=str(2:) ! Leaving out the sign.
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction str_i4p

  elemental function str_i2p(no_sign,n) result(str)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  logical,      intent(IN), optional:: no_sign
  integer(I2P), intent(IN)::           n
  character(DI2P)::                    str
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  write(str,fi2p) n                 ! Casting of n to string.
  str = adjustl(trim(str))          ! Removing white spaces.
  if (n>=0_i2p) str='+'//trim(str)  ! Prefixing plus if n>0.
  if (present(no_sign)) str=str(2:) ! Leaving out the sign.
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction str_i2p

  elemental function str_i1p(no_sign,n) result(str)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  logical,      intent(IN), optional:: no_sign
  integer(I1P), intent(IN)::           n
  character(DI1P)::                    str
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  write(str,fi1p) n                 ! Casting of n to string.
  str = adjustl(trim(str))          ! Removing white spaces.
  if (n>=0_i1p) str='+'//trim(str)  ! Prefixing plus if n>0.
  if (present(no_sign)) str=str(2:) ! Leaving out the sign.
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction str_i1p

  elemental function strz_i8p(nz_pad,n) result(str)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  integer(I4P), intent(IN), optional:: nz_pad
  integer(I8P), intent(IN)::           n
  character(DI8P)::                    str
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  write(str,fi8pzp) n                              ! Casting of n to string.
  str=str(2:)                                      ! Leaving out the sign.
  if (present(nz_pad)) str=str(di8p-nz_pad:di8p-1) ! Leaving out the extra zeros padding
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction strz_i8p

  elemental function strz_i4p(nz_pad,n) result(str)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  integer(I4P), intent(IN), optional:: nz_pad
  integer(I4P), intent(IN)::           n
  character(DI4P)::                    str
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  write(str,fi4pzp) n                              ! Casting of n to string.
  str=str(2:)                                      ! Leaving out the sign.
  if (present(nz_pad)) str=str(di4p-nz_pad:di4p-1) ! Leaving out the extra zeros padding
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction strz_i4p

  elemental function strz_i2p(nz_pad,n) result(str)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  integer(I4P), intent(IN), optional:: nz_pad
  integer(I2P), intent(IN)::           n
  character(DI2P)::                    str
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  write(str,fi2pzp) n                              ! Casting of n to string.
  str=str(2:)                                      ! Leaving out the sign.
  if (present(nz_pad)) str=str(di2p-nz_pad:di2p-1) ! Leaving out the extra zeros padding
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction strz_i2p

  elemental function strz_i1p(nz_pad,n) result(str)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  integer(I4P), intent(IN), optional:: nz_pad
  integer(I1P), intent(IN)::           n
  character(DI1P)::                    str
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  write(str,fi1pzp) n                              ! Casting of n to string.
  str=str(2:)                                      ! Leaving out the sign.
  if (present(nz_pad)) str=str(di1p-nz_pad:di1p-1) ! Leaving out the extra zeros padding
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction strz_i1p

  function ctor_r16p(str,knd) result(n)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  character(*), intent(IN):: str
  real(R16P),   intent(IN):: knd
  real(R16P)::               n
  integer(I4P)::             err
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  read(str,*,iostat=err) n ! Casting of str to n.
  if (err/=0) then
    write(stderr,'(A)')             'Conversion of string "'//str//'" to real failed'
    write(stderr,'(A,'//fr16p//')') 'Kind parameter ',knd
    write(stderr,'(A)')             'Function used "ctor_R16P"'
  endif
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction ctor_r16p

  function ctor_r8p(str,knd) result(n)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  character(*), intent(IN):: str
  real(R8P),    intent(IN):: knd
  real(R8P)::                n
  integer(I4P)::             err
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  read(str,*,iostat=err) n ! Casting of str to n.
  if (err/=0) then
    write(stderr,'(A)')            'Conversion of string "'//str//'" to real failed'
    write(stderr,'(A,'//fr8p//')') 'Kind parameter ',knd
    write(stderr,'(A)')            'Function used "ctor_R8P"'
  endif
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction ctor_r8p

  function ctor_r4p(str,knd) result(n)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  character(*), intent(IN):: str
  real(R4P),    intent(IN):: knd
  real(R4P)::                n
  integer(I4P)::             err
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  read(str,*,iostat=err) n ! Casting of str to n.
  if (err/=0) then
    write(stderr,'(A)')            'Conversion of string "'//str//'" to real failed'
    write(stderr,'(A,'//fr4p//')') 'Kind parameter ',knd
    write(stderr,'(A)')            'Function used "ctor_R4P"'
  endif
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction ctor_r4p

  function ctoi_i8p(str,knd) result(n)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  character(*), intent(IN):: str
  integer(I8P), intent(IN):: knd
  integer(I8P)::             n
  integer(I4P)::             err
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  read(str,*,iostat=err) n ! Casting of str to n.
  if (err/=0) then
    write(stderr,'(A)')            'Conversion of string "'//str//'" to integer failed'
    write(stderr,'(A,'//fi8p//')') 'Kind parameter ',knd
    write(stderr,'(A)')            'Function used "ctoi_I8P"'
  endif
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction ctoi_i8p

  function ctoi_i4p(str,knd) result(n)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  character(*), intent(IN):: str
  integer(I4P), intent(IN):: knd
  integer(I4P)::             n
  integer(I4P)::             err
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  read(str,*,iostat=err) n ! Casting of str to n.
  if (err/=0) then
    write(stderr,'(A)')            'Conversion of string "'//str//'" to integer failed'
    write(stderr,'(A,'//fi4p//')') 'Kind parameter ',knd
    write(stderr,'(A)')            'Function used "ctoi_I4P"'
  endif
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction ctoi_i4p

  function ctoi_i2p(str,knd) result(n)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  character(*), intent(IN):: str
  integer(I2P), intent(IN):: knd
  integer(I2P)::             n
  integer(I4P)::             err
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  read(str,*,iostat=err) n ! Casting of str to n.
  if (err/=0) then
    write(stderr,'(A)')            'Conversion of string "'//str//'" to integer failed'
    write(stderr,'(A,'//fi2p//')') 'Kind parameter ',knd
    write(stderr,'(A)')            'Function used "ctoi_I2P"'
  endif
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction ctoi_i2p

  function ctoi_i1p(str,knd) result(n)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  character(*), intent(IN):: str
  integer(I1P), intent(IN):: knd
  integer(I1P)::             n
  integer(I4P)::             err
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  read(str,*,iostat=err) n ! Casting of str to n.
  if (err/=0) then
    write(stderr,'(A)')            'Conversion of string "'//str//'" to integer failed'
    write(stderr,'(A,'//fi1p//')') 'Kind parameter ',knd
    write(stderr,'(A)')            'Function used "ctoi_I1P"'
  endif
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction ctoi_i1p

  elemental function bstr_r16p(n) result(bstr)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  real(R8P), intent(IN):: n
  character(128)::        bstr
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  write(bstr,'(B128.128)')n ! Casting of n to bit-string.
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction bstr_r16p

  elemental function bstr_r8p(n) result(bstr)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  real(R8P), intent(IN):: n
  character(64)::         bstr
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  write(bstr,'(B64.64)')n ! Casting of n to bit-string.
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction bstr_r8p

  elemental function bstr_r4p(n) result(bstr)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  real(R4P), intent(IN):: n
  character(32)::         bstr
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  write(bstr,'(B32.32)')n ! Casting of n to bit-string.
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction bstr_r4p

  elemental function bstr_i8p(n) result(bstr)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  integer(I8P), intent(IN):: n
  character(64)::            bstr
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  write(bstr,'(B64.64)')n ! Casting of n to bit-string.
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction bstr_i8p

  elemental function bstr_i4p(n) result(bstr)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  integer(I4P), intent(IN):: n
  character(32)::            bstr
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  write(bstr,'(B32.32)')n ! Casting of n to bit-string.
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction bstr_i4p

  elemental function bstr_i2p(n) result(bstr)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  integer(I2P), intent(IN):: n
  character(16)::            bstr
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  write(bstr,'(B16.16)')n ! Casting of n to bit-string.
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction bstr_i2p

  elemental function bstr_i1p(n) result(bstr)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  integer(I1P), intent(IN):: n
  character(8)::             bstr
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  write(bstr,'(B8.8)')n ! Casting of n to bit-string.
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction bstr_i1p

  elemental function bctor_r8p(bstr,knd) result(n)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  character(*), intent(IN):: bstr
  real(R8P),    intent(IN):: knd
  real(R8P)::                n
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  read(bstr,'(B'//trim(str(.true.,bit_size(knd)))//'.'//trim(str(.true.,bit_size(knd)))//')')n ! Casting of bstr to n.
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction bctor_r8p

  elemental function bctor_r4p(bstr,knd) result(n)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  character(*), intent(IN):: bstr
  real(R4P),    intent(IN):: knd
  real(R4P)::                n
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  read(bstr,'(B'//trim(str(.true.,bit_size(knd)))//'.'//trim(str(.true.,bit_size(knd)))//')')n ! Casting of bstr to n.
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction bctor_r4p

  elemental function bctoi_i8p(bstr,knd) result(n)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  character(*), intent(IN):: bstr
  integer(I8P), intent(IN):: knd
  integer(I8P)::             n
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  read(bstr,'(B'//trim(str(.true.,bit_size(knd)))//'.'//trim(str(.true.,bit_size(knd)))//')')n ! Casting of bstr to n.
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction bctoi_i8p

  elemental function bctoi_i4p(bstr,knd) result(n)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  character(*), intent(IN):: bstr
  integer(I4P), intent(IN):: knd
  integer(I4P)::             n
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  read(bstr,'(B'//trim(str(.true.,bit_size(knd)))//'.'//trim(str(.true.,bit_size(knd)))//')')n ! Casting of bstr to n.
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction bctoi_i4p

  elemental function bctoi_i2p(bstr,knd) result(n)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  character(*), intent(IN):: bstr
  integer(I2P), intent(IN):: knd
  integer(I2P)::             n
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  read(bstr,'(B'//trim(str(.true.,bit_size(knd)))//'.'//trim(str(.true.,bit_size(knd)))//')')n ! Casting of bstr to n.
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction bctoi_i2p

  elemental function bctoi_i1p(bstr,knd) result(n)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  character(*), intent(IN):: bstr
  integer(I1P), intent(IN):: knd
  integer(I1P)::             n
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  read(bstr,'(B'//trim(str(.true.,bit_size(knd)))//'.'//trim(str(.true.,bit_size(knd)))//')')n ! Casting of bstr to n.
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endfunction bctoi_i1p

  subroutine ir_init()
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  ! checking the bit ordering architecture
  call check_endian
  ! computing the bits/bytes sizes of real variables
  bir8p  = bit_size(r=maxr8p)  ; byr8p  = bir8p/8_i1p
  bir4p  = bit_size(r=maxr4p)  ; byr4p  = bir4p/8_i1p
  bir_p  = bit_size(r=maxr_p)  ; byr_p  = bir_p/8_i1p
#ifdef r16p
  bir16p = bit_size(r=maxr16p) ; byr16p = bir16p/8_i2p
#else
  bir16p = int(bir8p,kind=i2p) ; byr16p = bir16p/8_i2p
#endif
  ir_initialized = .true.
  return
  !---------------------------------------------------------------------------------------------------------------------------------
  endsubroutine ir_init

  subroutine ir_print(myrank,Nproc)
  !---------------------------------------------------------------------------------------------------------------------------------
  implicit none
  integer(I4P), intent(IN), optional:: myrank
  integer(I4P), intent(IN), optional:: nproc
  character(DI4P)::                    rks
  integer(I4P)::                       rank,np
  !---------------------------------------------------------------------------------------------------------------------------------

  !---------------------------------------------------------------------------------------------------------------------------------
  if (.not.ir_initialized) call ir_init
  rank = 0 ; if (present(myrank)) rank = myrank ; np = 1 ; if (present(nproc)) np = nproc ; rks = 'rank'//trim(strz(np,rank))
  ! printing informations
  if (endian==endianl) then
    write(stdout,'(A)')        trim(rks)//' This architecture has LITTLE Endian bit ordering'
  else
    write(stdout,'(A)')        trim(rks)//' This architecture has BIG Endian bit ordering'
  endif
  write(stdout,'(A)')          trim(rks)//' Reals kind precision definition'
  write(stdout,'(A,I2,A,I2,A)')trim(rks)//' R16P Kind "',r16p,'" | FR16P format "'//fr16p//'" | DR16P chars "',dr16p,'"'
  write(stdout,'(A,I2,A,I2,A)')trim(rks)//' R8P  Kind "',r8p, '" | FR8P  format "'//fr8p// '" | DR8P  chars "',dr8p ,'"'
  write(stdout,'(A,I2,A,I2,A)')trim(rks)//' R4P  Kind "',r4p, '" | FR4P  format "'//fr4p//'"  | DR4P  chars "',dr4p ,'"'
  write(stdout,'(A)')          trim(rks)//' Integers kind precision definition'
  write(stdout,'(A,I2,A,I2,A)')trim(rks)//' I8P Kind "',i8p,'" | FI8P format "'//fi8p// '" | DI8P chars "',di8p,'"'
  write(stdout,'(A,I2,A,I2,A)')trim(rks)//' I4P Kind "',i4p,'" | FI4P format "'//fi4p// '" | DI4P chars "',di4p,'"'
  write(stdout,'(A,I2,A,I2,A)')trim(rks)//' I2P Kind "',i2p,'" | FI2P format "'//fi2p//'"  | DI2P chars "',di2p,'"'
  write(stdout,'(A,I2,A,I2,A)')trim(rks)//' I1P Kind "',i1p,'" | FI1P format "'//fi1p//'"  | DI1P chars "',di1p,'"'
  write(stdout,'(A)')          trim(rks)//' Reals minimum and maximum values'
  write(stdout,'(A)')          trim(rks)//' MinR16P "'//trim(str(n=minr16p))//'" | MaxR16P "'//trim(str(n=maxr16p))//'"'
  write(stdout,'(A)')          trim(rks)//' MinR8P  "'//trim(str(n=minr8p))// '" | MaxR8P  "'//trim(str(n=maxr8p))// '"'
  write(stdout,'(A)')          trim(rks)//' MinR4P  "'//trim(str(n=minr4p))// '" | MaxR4P  "'//trim(str(n=maxr4p))// '"'
  write(stdout,'(A)')          trim(rks)//' Reals bits/bytes sizes'
  write(stdout,'(A,I2,A,I2,A)')trim(rks)//' R16P bits "',bir16p,'", bytes "',byr16p,'"'
  write(stdout,'(A,I2,A,I2,A)')trim(rks)//' R8P bits "', bir8p, '", bytes "',byr8p, '"'
  write(stdout,'(A,I2,A,I2,A)')trim(rks)//' R4P bits "', bir4p, '", bytes "',byr4p, '"'
  write(stdout,'(A,I2,A,I2,A)')trim(rks)//' R_P bits "', bir_p, '", bytes "',byr_p, '"'
  write(stdout,'(A)')          trim(rks)//' Integers minimum and maximum values'
  write(stdout,'(A)')          trim(rks)//' MinI8P "'//trim(str(n=mini8p))//'" | MaxI8P "'//trim(str(n=maxi8p))//'"'
  write(stdout,'(A)')          trim(rks)//' MinI4P "'//trim(str(n=mini4p))//'" | MaxI4P "'//trim(str(n=maxi4p))//'"'
  write(stdout,'(A)')          trim(rks)//' MinI2P "'//trim(str(n=mini2p))//'" | MaxI2P "'//trim(str(n=maxi2p))//'"'
  write(stdout,'(A)')          trim(rks)//' MinI1P "'//trim(str(n=mini1p))//'" | MaxI1P "'//trim(str(n=maxi1p))//'"'
  write(stdout,'(A)')          trim(rks)//' Integers bits/bytes sizes'
  write(stdout,'(A,I2,A,I2,A)')trim(rks)//' I8P bits "',bii8p,'", bytes "',byi8p,'"'
  write(stdout,'(A,I2,A,I2,A)')trim(rks)//' I4P bits "',bii4p,'", bytes "',byi4p,'"'
  write(stdout,'(A,I2,A,I2,A)')trim(rks)//' I2P bits "',bii2p,'", bytes "',byi2p,'"'
  write(stdout,'(A,I2,A,I2,A)')trim(rks)//' I1P bits "',bii1p,'", bytes "',byi1p,'"'
  write(stdout,'(A,I2,A,I2,A)')trim(rks)//' I_P bits "',bii_p,'", bytes "',byi_p,'"'
  write(stdout,'(A)')          trim(rks)//' Machine precisions'
  write(stdout,'(A)')          trim(rks)//' ZeroR16 "'//trim(str(.true.,zeror16))//'"'
  write(stdout,'(A)')          trim(rks)//' ZeroR8  "'//trim(str(.true.,zeror8 ))//'"'
  write(stdout,'(A)')          trim(rks)//' ZeroR4  "'//trim(str(.true.,zeror4 ))//'"'
  !---------------------------------------------------------------------------------------------------------------------------------
  endsubroutine ir_print
endmodule ir_precision