doxygen-example/tools__missing_8_f90_source.html

 !----------------------------------------------------------------------
 ! Module: tools_missing
 ! Purpose: deal with missing values
 ! Author: Benjamin Menetrier
 ! Licensing: this code is distributed under the CeCILL-C license
 ! Copyright © 2015-... UCAR, CERFACS, METEO-FRANCE and IRIT
 !----------------------------------------------------------------------
 module tools_missing

 use tools_const, only: msvali,msvalr
 use tools_kinds,only: kind_real

 implicit none

 interface msi
   module procedure msi_0d
   module procedure msi_1d
   module procedure msi_2d
   module procedure msi_3d
   module procedure msi_4d
   module procedure msi_5d
   module procedure msi_6d
 end interface
 interface msr
   module procedure msr_0d
   module procedure msr_1d
   module procedure msr_2d
   module procedure msr_3d
   module procedure msr_4d
   module procedure msr_5d
   module procedure msr_6d
 end interface
 interface isnotmsi
   module procedure isnotmsi_0d
   module procedure isnotmsi_1d
   module procedure isnotmsi_2d
   module procedure isnotmsi_3d
   module procedure isnotmsi_4d
   module procedure isnotmsi_5d
 end interface
 interface ismsi
   module procedure ismsi_0d
   module procedure ismsi_1d
   module procedure ismsi_2d
   module procedure ismsi_3d
   module procedure ismsi_4d
   module procedure ismsi_5d
 end interface
 interface isnotmsr
   module procedure isnotmsr_0d
   module procedure isnotmsr_1d
   module procedure isnotmsr_2d
   module procedure isnotmsr_3d
   module procedure isnotmsr_4d
   module procedure isnotmsr_5d
 end interface
 interface ismsr
   module procedure ismsr_0d
   module procedure ismsr_1d
   module procedure ismsr_2d
   module procedure ismsr_3d
   module procedure ismsr_4d
   module procedure ismsr_5d
 end interface
 interface isanynotmsi
   module procedure isanynotmsi_1d
   module procedure isanynotmsi_2d
   module procedure isanynotmsi_3d
   module procedure isanynotmsi_4d
   module procedure isanynotmsi_5d
 end interface
 interface isanymsi
   module procedure isanymsi_1d
   module procedure isanymsi_2d
   module procedure isanymsi_3d
   module procedure isanymsi_4d
   module procedure isanymsi_5d
 end interface
 interface isanynotmsr
   module procedure isanynotmsr_1d
   module procedure isanynotmsr_2d
   module procedure isanynotmsr_3d
   module procedure isanynotmsr_4d
   module procedure isanynotmsr_5d
 end interface
 interface isanymsr
   module procedure isanymsr_1d
   module procedure isanymsr_2d
   module procedure isanymsr_3d
   module procedure isanymsr_4d
   module procedure isanymsr_5d
 end interface
 interface isallnotmsi
   module procedure isallnotmsi_1d
   module procedure isallnotmsi_2d
   module procedure isallnotmsi_3d
   module procedure isallnotmsi_4d
   module procedure isallnotmsi_5d
 end interface
 interface isallmsi
   module procedure isallmsi_1d
   module procedure isallmsi_2d
   module procedure isallmsi_3d
   module procedure isallmsi_4d
   module procedure isallmsi_5d
 end interface
 interface isallnotmsr
   module procedure isallnotmsr_1d
   module procedure isallnotmsr_2d
   module procedure isallnotmsr_3d
   module procedure isallnotmsr_4d
   module procedure isallnotmsr_5d
 end interface
 interface isallmsr
   module procedure isallmsr_1d
   module procedure isallmsr_2d
   module procedure isallmsr_3d
   module procedure isallmsr_4d
   module procedure isallmsr_5d
 end interface

 private
 public :: msi,msr,isnotmsi,ismsi,isnotmsr,ismsr,isanynotmsi,isanymsi,isanynotmsr,isanymsr,isallnotmsi,isallmsi,isallnotmsr,isallmsr

 contains

 !----------------------------------------------------------------------
 ! Subroutine: msi_0d
 ! Purpose: set integer to missing value
 !----------------------------------------------------------------------
 subroutine msi_0d(i)

 implicit none

 ! Passed variables
 integer,intent(out),optional :: i ! Integer

 i = msvali

 end subroutine msi_0d

 !----------------------------------------------------------------------
 ! Subroutine: msi_1d
 ! Purpose: set integer to missing value
 !----------------------------------------------------------------------
 subroutine msi_1d(i)

 implicit none

 ! Passed variables
 integer,intent(out) :: i(:) ! Integer

 i = msvali

 end subroutine msi_1d

 !----------------------------------------------------------------------
 ! Subroutine: msi_2d
 ! Purpose: set integer to missing value
 !----------------------------------------------------------------------
 subroutine msi_2d(i)

 implicit none

 ! Passed variables
 integer,intent(out) :: i(:,:) ! Integer

 i = msvali

 end subroutine msi_2d

 !----------------------------------------------------------------------
 ! Subroutine: msi_3d
 ! Purpose: set integer to missing value
 !----------------------------------------------------------------------
 subroutine msi_3d(i)

 implicit none

 ! Passed variables
 integer,intent(out) :: i(:,:,:) ! Integer

 i = msvali

 end subroutine msi_3d

 !----------------------------------------------------------------------
 ! Subroutine: msi_4d
 ! Purpose: set integer to missing value
 !----------------------------------------------------------------------
 subroutine msi_4d(i)

 implicit none

 ! Passed variables
 integer,intent(out) :: i(:,:,:,:) ! Integer

 i = msvali

 end subroutine msi_4d

 !----------------------------------------------------------------------
 ! Subroutine: msi_5d
 ! Purpose: set integer to missing value
 !----------------------------------------------------------------------
 subroutine msi_5d(i)

 implicit none

 ! Passed variables
 integer,intent(out) :: i(:,:,:,:,:) ! Integer

 i = msvali

 end subroutine msi_5d

 !----------------------------------------------------------------------
 ! Subroutine: msi_6d
 ! Purpose: set integer to missing value
 !----------------------------------------------------------------------
 subroutine msi_6d(i)

 implicit none

 ! Passed variables
 integer,intent(out) :: i(:,:,:,:,:,:) ! Integer

 i = msvali

 end subroutine msi_6d

 !----------------------------------------------------------------------
 ! Subroutine: msr_0d
 ! Purpose: set real number to missing value
 !----------------------------------------------------------------------
 subroutine msr_0d(r)

 implicit none

 ! Passed variables
 real(kind_real),intent(out) :: r ! Real number

 r = msvalr

 end subroutine msr_0d

 !----------------------------------------------------------------------
 ! Subroutine: msr_1d
 ! Purpose: set real number to missing value
 !----------------------------------------------------------------------
 subroutine msr_1d(r)

 implicit none

 ! Passed variables
 real(kind_real),intent(out) :: r(:) ! Real number

 r = msvalr

 end subroutine msr_1d

 !----------------------------------------------------------------------
 ! Subroutine: msr_2d
 ! Purpose: set real number to missing value
 !----------------------------------------------------------------------
 subroutine msr_2d(r)

 implicit none

 ! Passed variables
 real(kind_real),intent(out) :: r(:,:) ! Real number

 r = msvalr

 end subroutine msr_2d

 !----------------------------------------------------------------------
 ! Subroutine: msr_3d
 ! Purpose: set real number to missing value
 !----------------------------------------------------------------------
 subroutine msr_3d(r)

 implicit none

 ! Passed variables
 real(kind_real),intent(out) :: r(:,:,:) ! Real number

 r = msvalr

 end subroutine msr_3d

 !----------------------------------------------------------------------
 ! Subroutine: msr_4d
 ! Purpose: set real number to missing value
 !----------------------------------------------------------------------
 subroutine msr_4d(r)

 implicit none

 ! Passed variables
 real(kind_real),intent(out) :: r(:,:,:,:) ! Real number

 r = msvalr

 end subroutine msr_4d

 !----------------------------------------------------------------------
 ! Subroutine: msr_5d
 ! Purpose: set real number to missing value
 !----------------------------------------------------------------------
 subroutine msr_5d(r)

 implicit none

 ! Passed variables
 real(kind_real),intent(out) :: r(:,:,:,:,:) ! Real number

 r = msvalr

 end subroutine msr_5d

 !----------------------------------------------------------------------
 ! Subroutine: msr_6d
 ! Purpose: set real number to missing value
 !----------------------------------------------------------------------
 subroutine msr_6d(r)

 implicit none

 ! Passed variables
 real(kind_real),intent(out) :: r(:,:,:,:,:,:) ! Real number

 r = msvalr

 end subroutine msr_6d

 !----------------------------------------------------------------------
 ! Function: isnotmsi_0d
 ! Purpose: check if an integer is not set to missing value
 !----------------------------------------------------------------------
 function isnotmsi_0d(i)

 implicit none

 ! Passed variables
 integer,intent(in) :: i ! Integer

 ! Returned value
 logical :: isnotmsi_0d

 isnotmsi_0d = abs(i-msvali)>0

 end function isnotmsi_0d

 !----------------------------------------------------------------------
 ! Function: isnotmsi_1d
 ! Purpose: check if an integer is not set to missing value
 !----------------------------------------------------------------------
 function isnotmsi_1d(i)

 implicit none

 ! Passed variables
 integer,intent(in) :: i(:) ! Integer

 ! Returned value
 logical :: isnotmsi_1d(max(size(i),1))

 if (size(i)>0) then
    isnotmsi_1d = abs(i-msvali)>0
 else
    isnotmsi_1d = .false.
 end if

 end function isnotmsi_1d

 !----------------------------------------------------------------------
 ! Function: isnotmsi_2d
 ! Purpose: check if an integer is not set to missing value
 !----------------------------------------------------------------------
 function isnotmsi_2d(i)

 implicit none

 ! Passed variables
 integer,intent(in) :: i(:,:) ! Integer

 ! Returned value
 logical :: isnotmsi_2d(max(size(i,1),1),max(size(i,2),1))

 if (size(i)>0) then
    isnotmsi_2d = abs(i-msvali)>0
 else
    isnotmsi_2d = .false.
 end if

 end function isnotmsi_2d

 !----------------------------------------------------------------------
 ! Function: isnotmsi_3d
 ! Purpose: check if an integer is not set to missing value
 !----------------------------------------------------------------------
 function isnotmsi_3d(i)

 implicit none

 ! Passed variables
 integer,intent(in) :: i(:,:,:) ! Integer

 ! Returned value
 logical :: isnotmsi_3d(max(size(i,1),1),max(size(i,2),1),max(size(i,3),1))

 if (size(i)>0) then
    isnotmsi_3d = abs(i-msvali)>0
 else
    isnotmsi_3d = .false.
 end if

 end function isnotmsi_3d

 !----------------------------------------------------------------------
 ! Function: isnotmsi_4d
 ! Purpose: check if an integer is not set to missing value
 !----------------------------------------------------------------------
 function isnotmsi_4d(i)

 implicit none

 ! Passed variables
 integer,intent(in) :: i(:,:,:,:) ! Integer

 ! Returned value
 logical :: isnotmsi_4d(max(size(i,1),1),max(size(i,2),1),max(size(i,3),1),max(size(i,4),1))

 if (size(i)>0) then
    isnotmsi_4d = abs(i-msvali)>0
 else
    isnotmsi_4d = .false.
 end if

 end function isnotmsi_4d

 !----------------------------------------------------------------------
 ! Function: isnotmsi_5d
 ! Purpose: check if an integer is not set to missing value
 !----------------------------------------------------------------------
 function isnotmsi_5d(i)

 implicit none

 ! Passed variables
 integer,intent(in) :: i(:,:,:,:,:) ! Integer

 ! Returned value
 logical :: isnotmsi_5d(max(size(i,1),1),max(size(i,2),1),max(size(i,3),1),max(size(i,4),1),max(size(i,5),1))

 if (size(i)>0) then
    isnotmsi_5d = abs(i-msvali)>0
 else
    isnotmsi_5d = .false.
 end if

 end function isnotmsi_5d

 !----------------------------------------------------------------------
 ! Function: ismsi_0d
 ! Purpose: check if an integer is set to missing value
 !----------------------------------------------------------------------
 function ismsi_0d(i)

 implicit none

 ! Passed variables
 integer,intent(in) :: i ! Integer

 ! Returned value
 logical :: ismsi_0d

 ismsi_0d = .not.isnotmsi(i)

 end function ismsi_0d

 !----------------------------------------------------------------------
 ! Function: ismsi_1d
 ! Purpose: check if an integer is set to missing value
 !----------------------------------------------------------------------
 function ismsi_1d(i)

 implicit none

 ! Passed variables
 integer,intent(in) :: i(:) ! Integer

 ! Returned value
 logical :: ismsi_1d(max(size(i),1))

 ismsi_1d = .not.isnotmsi(i)

 end function ismsi_1d

 !----------------------------------------------------------------------
 ! Function: ismsi_2d
 ! Purpose: check if an integer is set to missing value
 !----------------------------------------------------------------------
 function ismsi_2d(i)

 implicit none

 ! Passed variables
 integer,intent(in) :: i(:,:) ! Integer

 ! Returned value
 logical :: ismsi_2d(max(size(i,1),1),max(size(i,2),1))

 ismsi_2d = .not.isnotmsi(i)

 end function ismsi_2d

 !----------------------------------------------------------------------
 ! Function: ismsi_3d
 ! Purpose: check if an integer is set to missing value
 !----------------------------------------------------------------------
 function ismsi_3d(i)

 implicit none

 ! Passed variables
 integer,intent(in) :: i(:,:,:) ! Integer

 ! Returned value
 logical :: ismsi_3d(max(size(i,1),1),max(size(i,2),1),max(size(i,3),1))

 ismsi_3d = .not.isnotmsi(i)

 end function ismsi_3d

 !----------------------------------------------------------------------
 ! Function: ismsi_4d
 ! Purpose: check if an integer is set to missing value
 !----------------------------------------------------------------------
 function ismsi_4d(i)

 implicit none

 ! Passed variables
 integer,intent(in) :: i(:,:,:,:) ! Integer

 ! Returned value
 logical :: ismsi_4d(max(size(i,1),1),max(size(i,2),1),max(size(i,3),1),max(size(i,4),1))

 ismsi_4d = .not.isnotmsi(i)

 end function ismsi_4d

 !----------------------------------------------------------------------
 ! Function: ismsi_5d
 ! Purpose: check if an integer is set to missing value
 !----------------------------------------------------------------------
 function ismsi_5d(i)

 implicit none

 ! Passed variables
 integer,intent(in) :: i(:,:,:,:,:) ! Integer

 ! Returned value
 logical :: ismsi_5d(max(size(i,1),1),max(size(i,2),1),max(size(i,3),1),max(size(i,4),1),max(size(i,5),1))

 ismsi_5d = .not.isnotmsi(i)

 end function ismsi_5d

 !----------------------------------------------------------------------
 ! Function: isnotmsr_0d
 ! Purpose: check if an real number is not set to missing value
 !----------------------------------------------------------------------
 function isnotmsr_0d(r)

 implicit none

 ! Passed variables
 real(kind_real),intent(in) :: r ! Real number

 ! Returned value
 logical :: isnotmsr_0d

 isnotmsr_0d = abs(r-msvalr)>0.0

 end function isnotmsr_0d

 !----------------------------------------------------------------------
 ! Function: isnotmsr_1d
 ! Purpose: check if an real number is not set to missing value
 !----------------------------------------------------------------------
 function isnotmsr_1d(r)

 implicit none

 ! Passed variables
 real(kind_real),intent(in) :: r(:) ! Real number

 ! Returned value
 logical :: isnotmsr_1d(size(r))

 if (size(r)>0) then
    isnotmsr_1d = abs(r-msvalr)>0.0
 else
    isnotmsr_1d = .false.
 end if

 end function isnotmsr_1d

 !----------------------------------------------------------------------
 ! Function: isnotmsr_2d
 ! Purpose: check if an real number is not set to missing value
 !----------------------------------------------------------------------
 function isnotmsr_2d(r)

 implicit none

 ! Passed variables
 real(kind_real),intent(in) :: r(:,:) ! Real number

 ! Returned value
 logical :: isnotmsr_2d(max(size(r,1),1),max(size(r,2),1))

 if (size(r)>0) then
    isnotmsr_2d = abs(r-msvalr)>0.0
 else
    isnotmsr_2d = .false.
 end if

 end function isnotmsr_2d

 !----------------------------------------------------------------------
 ! Function: isnotmsr_3d
 ! Purpose: check if an real number is not set to missing value
 !----------------------------------------------------------------------
 function isnotmsr_3d(r)

 implicit none

 ! Passed variables
 real(kind_real),intent(in) :: r(:,:,:) ! Real number

 ! Returned value
 logical :: isnotmsr_3d(max(size(r,1),1),max(size(r,2),1),max(size(r,3),1))

 if (size(r)>0) then
    isnotmsr_3d = abs(r-msvalr)>0.0
 else
    isnotmsr_3d = .false.
 end if

 end function isnotmsr_3d

 !----------------------------------------------------------------------
 ! Function: isnotmsr_4d
 ! Purpose: check if an real number is not set to missing value
 !----------------------------------------------------------------------
 function isnotmsr_4d(r)

 implicit none

 ! Passed variables
 real(kind_real),intent(in) :: r(:,:,:,:) ! Real number

 ! Returned value
 logical :: isnotmsr_4d(max(size(r,1),1),max(size(r,2),1),max(size(r,3),1),max(size(r,4),1))

 if (size(r)>0) then
    isnotmsr_4d = abs(r-msvalr)>0.0
 else
    isnotmsr_4d = .false.
 end if

 end function isnotmsr_4d

 !----------------------------------------------------------------------
 ! Function: isnotmsr_5d
 ! Purpose: check if an real number is not set to missing value
 !----------------------------------------------------------------------
 function isnotmsr_5d(r)

 implicit none

 ! Passed variables
 real(kind_real),intent(in) :: r(:,:,:,:,:) ! Real number

 ! Returned value
 logical :: isnotmsr_5d(max(size(r,1),1),max(size(r,2),1),max(size(r,3),1),max(size(r,4),1),max(size(r,5),1))

 if (size(r)>0) then
    isnotmsr_5d = abs(r-msvalr)>0.0
 else
    isnotmsr_5d = .false.
 end if

 end function isnotmsr_5d

 !----------------------------------------------------------------------
 ! Function: ismsr_0d
 ! Purpose: check if an real number is set to missing value
 !----------------------------------------------------------------------
 function ismsr_0d(r)

 implicit none

 ! Passed variables
 real(kind_real),intent(in) :: r ! Real number

 ! Returned value
 logical :: ismsr_0d

 ismsr_0d = .not.isnotmsr(r)

 end function ismsr_0d

 !----------------------------------------------------------------------
 ! Function: ismsr_1d
 ! Purpose: check if an real number is set to missing value
 !----------------------------------------------------------------------
 function ismsr_1d(r)

 implicit none

 ! Passed variables
 real(kind_real),intent(in) :: r(:) ! Real number

 ! Returned value
 logical :: ismsr_1d(size(r))

 ismsr_1d = .not.isnotmsr(r)

 end function ismsr_1d

 !----------------------------------------------------------------------
 ! Function: ismsr_2d
 ! Purpose: check if an real number is set to missing value
 !----------------------------------------------------------------------
 function ismsr_2d(r)

 implicit none

 ! Passed variables
 real(kind_real),intent(in) :: r(:,:) ! Real number

 ! Returned value
 logical :: ismsr_2d(max(size(r,1),1),max(size(r,2),1))

 ismsr_2d = .not.isnotmsr(r)

 end function ismsr_2d

 !----------------------------------------------------------------------
 ! Function: ismsr_3d
 ! Purpose: check if an real number is set to missing value
 !----------------------------------------------------------------------
 function ismsr_3d(r)

 implicit none

 ! Passed variables
 real(kind_real),intent(in) :: r(:,:,:) ! Real number

 ! Returned value
 logical :: ismsr_3d(max(size(r,1),1),max(size(r,2),1),max(size(r,3),1))

 ismsr_3d = .not.isnotmsr(r)

 end function ismsr_3d

 !----------------------------------------------------------------------
 ! Function: ismsr_4d
 ! Purpose: check if an real number is set to missing value
 !----------------------------------------------------------------------
 function ismsr_4d(r)

 implicit none

 ! Passed variables
 real(kind_real),intent(in) :: r(:,:,:,:) ! Real number

 ! Returned value
 logical :: ismsr_4d(max(size(r,1),1),max(size(r,2),1),max(size(r,3),1),max(size(r,4),1))

 ismsr_4d = .not.isnotmsr(r)

 end function ismsr_4d

 !----------------------------------------------------------------------
 ! Function: ismsr_5d
 ! Purpose: check if an real number is set to missing value
 !----------------------------------------------------------------------
 function ismsr_5d(r)

 implicit none

 ! Passed variables
 real(kind_real),intent(in) :: r(:,:,:,:,:) ! Real number

 ! Returned value
 logical :: ismsr_5d(max(size(r,1),1),max(size(r,2),1),max(size(r,3),1),max(size(r,4),1),max(size(r,5),1))

 ismsr_5d = .not.isnotmsr(r)

 end function ismsr_5d

 !----------------------------------------------------------------------
 ! Function: isanynotmsi_1d
 ! Purpose: check if an integer is not set to missing value
 !----------------------------------------------------------------------
 logical function isanynotmsi_1d(i)

 implicit none

 ! Passed variables
 integer,intent(in) :: i(:) ! Integer

 isanynotmsi_1d = any(isnotmsi(i))

 end function isanynotmsi_1d

 !----------------------------------------------------------------------
 ! Function: isanynotmsi_2d
 ! Purpose: check if an integer is not set to missing value
 !----------------------------------------------------------------------
 logical function isanynotmsi_2d(i)

 implicit none

 ! Passed variables
 integer,intent(in) :: i(:,:) ! Integer

 isanynotmsi_2d = any(isnotmsi(i))

 end function isanynotmsi_2d

 !----------------------------------------------------------------------
 ! Function: isanynotmsi_3d
 ! Purpose: check if an integer is not set to missing value
 !----------------------------------------------------------------------
 logical function isanynotmsi_3d(i)

 implicit none

 ! Passed variables
 integer,intent(in) :: i(:,:,:) ! Integer

 isanynotmsi_3d = any(isnotmsi(i))

 end function isanynotmsi_3d

 !----------------------------------------------------------------------
 ! Function: isanynotmsi_4d
 ! Purpose: check if an integer is not set to missing value
 !----------------------------------------------------------------------
 logical function isanynotmsi_4d(i)

 implicit none

 ! Passed variables
 integer,intent(in) :: i(:,:,:,:) ! Integer

 isanynotmsi_4d = any(isnotmsi(i))

 end function isanynotmsi_4d

 !----------------------------------------------------------------------
 ! Function: isanynotmsi_5d
 ! Purpose: check if an integer is not set to missing value
 !----------------------------------------------------------------------
 logical function isanynotmsi_5d(i)

 implicit none

 ! Passed variables
 integer,intent(in) :: i(:,:,:,:,:) ! Integer

 isanynotmsi_5d = any(isnotmsi(i))

 end function isanynotmsi_5d

 !----------------------------------------------------------------------
 ! Function: isanymsi_1d
 ! Purpose: check if an integer is set to missing value
 !----------------------------------------------------------------------
 logical function isanymsi_1d(i)

 implicit none

 ! Passed variables
 integer,intent(in) :: i(:) ! Integer

 isanymsi_1d = .not.isallnotmsi(i)

 end function isanymsi_1d

 !----------------------------------------------------------------------
 ! Function: isanymsi_2d
 ! Purpose: check if an integer is set to missing value
 !----------------------------------------------------------------------
 logical function isanymsi_2d(i)

 implicit none

 ! Passed variables
 integer,intent(in) :: i(:,:) ! Integer

 isanymsi_2d = .not.isallnotmsi(i)

 end function isanymsi_2d

 !----------------------------------------------------------------------
 ! Function: isanymsi_3d
 ! Purpose: check if an integer is set to missing value
 !----------------------------------------------------------------------
 logical function isanymsi_3d(i)

 implicit none

 ! Passed variables
 integer,intent(in) :: i(:,:,:) ! Integer

 isanymsi_3d = .not.isallnotmsi(i)

 end function isanymsi_3d

 !----------------------------------------------------------------------
 ! Function: isanymsi_4d
 ! Purpose: check if an integer is set to missing value
 !----------------------------------------------------------------------
 logical function isanymsi_4d(i)

 implicit none

 ! Passed variables
 integer,intent(in) :: i(:,:,:,:) ! Integer

 isanymsi_4d = .not.isallnotmsi(i)

 end function isanymsi_4d

 !----------------------------------------------------------------------
 ! Function: isanymsi_5d
 ! Purpose: check if an integer is set to missing value
 !----------------------------------------------------------------------
 logical function isanymsi_5d(i)

 implicit none

 ! Passed variables
 integer,intent(in) :: i(:,:,:,:,:) ! Integer

 isanymsi_5d = .not.isallnotmsi(i)

 end function isanymsi_5d

 !----------------------------------------------------------------------
 ! Function: isanynotmsr_1d
 ! Purpose: check if a real is not set to missing value
 !----------------------------------------------------------------------
 logical function isanynotmsr_1d(r)

 implicit none

 ! Passed variables
 real(kind_real),intent(in) :: r(:) ! Real

 isanynotmsr_1d = any(isnotmsr(r))

 end function isanynotmsr_1d

 !----------------------------------------------------------------------
 ! Function: isanynotmsr_2d
 ! Purpose: check if a real is not set to missing value
 !----------------------------------------------------------------------
 logical function isanynotmsr_2d(r)

 implicit none

 ! Passed variables
 real(kind_real),intent(in) :: r(:,:) ! Real

 isanynotmsr_2d = any(isnotmsr(r))

 end function isanynotmsr_2d

 !----------------------------------------------------------------------
 ! Function: isanynotmsr_3d
 ! Purpose: check if a real is not set to missing value
 !----------------------------------------------------------------------
 logical function isanynotmsr_3d(r)

 implicit none

 ! Passed variables
 real(kind_real),intent(in) :: r(:,:,:) ! Real

 isanynotmsr_3d = any(isnotmsr(r))

 end function isanynotmsr_3d

 !----------------------------------------------------------------------
 ! Function: isanynotmsr_4d
 ! Purpose: check if a real is not set to missing value
 !----------------------------------------------------------------------
 logical function isanynotmsr_4d(r)

 implicit none

 ! Passed variables
 real(kind_real),intent(in) :: r(:,:,:,:) ! Real

 isanynotmsr_4d = any(isnotmsr(r))

 end function isanynotmsr_4d

 !----------------------------------------------------------------------
 ! Function: isanynotmsr_5d
 ! Purpose: check if a real is not set to missing value
 !----------------------------------------------------------------------
 logical function isanynotmsr_5d(r)

 implicit none

 ! Passed variables
 real(kind_real),intent(in) :: r(:,:,:,:,:) ! Real

 isanynotmsr_5d = any(isnotmsr(r))

 end function isanynotmsr_5d

 !----------------------------------------------------------------------
 ! Function: isanymsr_1d
 ! Purpose: check if a real is set to missing value
 !----------------------------------------------------------------------
 logical function isanymsr_1d(r)

 implicit none

 ! Passed variables
 real(kind_real),intent(in) :: r(:) ! Real

 isanymsr_1d = .not.isallmsr(r)

 end function isanymsr_1d

 !----------------------------------------------------------------------
 ! Function: isanymsr_2d
 ! Purpose: check if a real is set to missing value
 !----------------------------------------------------------------------
 logical function isanymsr_2d(r)

 implicit none

 ! Passed variables
 real(kind_real),intent(in) :: r(:,:) ! Real

 isanymsr_2d = .not.isallmsr(r)

 end function isanymsr_2d

 !----------------------------------------------------------------------
 ! Function: isanymsr_3d
 ! Purpose: check if a real is set to missing value
 !----------------------------------------------------------------------
 logical function isanymsr_3d(r)

 implicit none

 ! Passed variables
 real(kind_real),intent(in) :: r(:,:,:) ! Real

 isanymsr_3d = .not.isallmsr(r)

 end function isanymsr_3d

 !----------------------------------------------------------------------
 ! Function: isanymsr_4d
 ! Purpose: check if a real is set to missing value
 !----------------------------------------------------------------------
 logical function isanymsr_4d(r)

 implicit none

 ! Passed variables
 real(kind_real),intent(in) :: r(:,:,:,:) ! Real

 isanymsr_4d = .not.isallmsr(r)

 end function isanymsr_4d

 !----------------------------------------------------------------------
 ! Function: isanymsr_5d
 ! Purpose: check if a real is set to missing value
 !----------------------------------------------------------------------
 logical function isanymsr_5d(r)

 implicit none

 ! Passed variables
 real(kind_real),intent(in) :: r(:,:,:,:,:) ! Real

 isanymsr_5d = .not.isallmsr(r)

 end function isanymsr_5d

 !----------------------------------------------------------------------
 ! Function: isallnotmsi_1d
 ! Purpose: check if an integer is not set to missing value
 !----------------------------------------------------------------------
 logical function isallnotmsi_1d(i)

 implicit none

 ! Passed variables
 integer,intent(in) :: i(:) ! Integer

 isallnotmsi_1d = all(isnotmsi(i))

 end function isallnotmsi_1d

 !----------------------------------------------------------------------
 ! Function: isallnotmsi_2d
 ! Purpose: check if an integer is not set to missing value
 !----------------------------------------------------------------------
 logical function isallnotmsi_2d(i)

 implicit none

 ! Passed variables
 integer,intent(in) :: i(:,:) ! Integer

 isallnotmsi_2d = all(isnotmsi(i))

 end function isallnotmsi_2d

 !----------------------------------------------------------------------
 ! Function: isallnotmsi_3d
 ! Purpose: check if an integer is not set to missing value
 !----------------------------------------------------------------------
 logical function isallnotmsi_3d(i)

 implicit none

 ! Passed variables
 integer,intent(in) :: i(:,:,:) ! Integer

 isallnotmsi_3d = all(isnotmsi(i))

 end function isallnotmsi_3d

 !----------------------------------------------------------------------
 ! Function: isallnotmsi_4d
 ! Purpose: check if an integer is not set to missing value
 !----------------------------------------------------------------------
 logical function isallnotmsi_4d(i)

 implicit none

 ! Passed variables
 integer,intent(in) :: i(:,:,:,:) ! Integer

 isallnotmsi_4d = all(isnotmsi(i))

 end function isallnotmsi_4d

 !----------------------------------------------------------------------
 ! Function: isallnotmsi_5d
 ! Purpose: check if an integer is not set to missing value
 !----------------------------------------------------------------------
 logical function isallnotmsi_5d(i)

 implicit none

 ! Passed variables
 integer,intent(in) :: i(:,:,:,:,:) ! Integer

 isallnotmsi_5d = all(isnotmsi(i))

 end function isallnotmsi_5d

 !----------------------------------------------------------------------
 ! Function: isallmsi_1d
 ! Purpose: check if an integer is set to missing value
 !----------------------------------------------------------------------
 logical function isallmsi_1d(i)

 implicit none

 ! Passed variables
 integer,intent(in) :: i(:) ! Integer

 isallmsi_1d = .not.isanynotmsi(i)

 end function isallmsi_1d

 !----------------------------------------------------------------------
 ! Function: isallmsi_2d
 ! Purpose: check if an integer is set to missing value
 !----------------------------------------------------------------------
 logical function isallmsi_2d(i)

 implicit none

 ! Passed variables
 integer,intent(in) :: i(:,:) ! Integer

 isallmsi_2d = .not.isanynotmsi(i)

 end function isallmsi_2d

 !----------------------------------------------------------------------
 ! Function: isallmsi_3d
 ! Purpose: check if an integer is set to missing value
 !----------------------------------------------------------------------
 logical function isallmsi_3d(i)

 implicit none

 ! Passed variables
 integer,intent(in) :: i(:,:,:) ! Integer

 isallmsi_3d = .not.isanynotmsi(i)

 end function isallmsi_3d

 !----------------------------------------------------------------------
 ! Function: isallmsi_4d
 ! Purpose: check if an integer is set to missing value
 !----------------------------------------------------------------------
 logical function isallmsi_4d(i)

 implicit none

 ! Passed variables
 integer,intent(in) :: i(:,:,:,:) ! Integer

 isallmsi_4d = .not.isanynotmsi(i)

 end function isallmsi_4d

 !----------------------------------------------------------------------
 ! Function: isallmsi_5d
 ! Purpose: check if an integer is set to missing value
 !----------------------------------------------------------------------
 logical function isallmsi_5d(i)

 implicit none

 ! Passed variables
 integer,intent(in) :: i(:,:,:,:,:) ! Integer

 isallmsi_5d = .not.isanynotmsi(i)

 end function isallmsi_5d

 !----------------------------------------------------------------------
 ! Function: isallnotmsr_1d
 ! Purpose: check if a real is not set to missing value
 !----------------------------------------------------------------------
 logical function isallnotmsr_1d(r)

 implicit none

 ! Passed variables
 real(kind_real),intent(in) :: r(:) ! Real

 isallnotmsr_1d = all(isnotmsr(r))

 end function isallnotmsr_1d

 !----------------------------------------------------------------------
 ! Function: isallnotmsr_2d
 ! Purpose: check if a real is not set to missing value
 !----------------------------------------------------------------------
 logical function isallnotmsr_2d(r)

 implicit none

 ! Passed variables
 real(kind_real),intent(in) :: r(:,:) ! Real

 isallnotmsr_2d = all(isnotmsr(r))

 end function isallnotmsr_2d

 !----------------------------------------------------------------------
 ! Function: isallnotmsr_3d
 ! Purpose: check if a real is not set to missing value
 !----------------------------------------------------------------------
 logical function isallnotmsr_3d(r)

 implicit none

 ! Passed variables
 real(kind_real),intent(in) :: r(:,:,:) ! Real

 isallnotmsr_3d = all(isnotmsr(r))

 end function isallnotmsr_3d

 !----------------------------------------------------------------------
 ! Function: isallnotmsr_4d
 ! Purpose: check if a real is not set to missing value
 !----------------------------------------------------------------------
 logical function isallnotmsr_4d(r)

 implicit none

 ! Passed variables
 real(kind_real),intent(in) :: r(:,:,:,:) ! Real

 isallnotmsr_4d = all(isnotmsr(r))

 end function isallnotmsr_4d

 !----------------------------------------------------------------------
 ! Function: isallnotmsr_5d
 ! Purpose: check if a real is not set to missing value
 !----------------------------------------------------------------------
 logical function isallnotmsr_5d(r)

 implicit none

 ! Passed variables
 real(kind_real),intent(in) :: r(:,:,:,:,:) ! Real

 isallnotmsr_5d = all(isnotmsr(r))

 end function isallnotmsr_5d

 !----------------------------------------------------------------------
 ! Function: isallmsr_1d
 ! Purpose: check if a real is set to missing value
 !----------------------------------------------------------------------
 logical function isallmsr_1d(r)

 implicit none

 ! Passed variables
 real(kind_real),intent(in) :: r(:) ! Real

 isallmsr_1d = .not.isanynotmsr(r)

 end function isallmsr_1d

 !----------------------------------------------------------------------
 ! Function: isallmsr_2d
 ! Purpose: check if a real is set to missing value
 !----------------------------------------------------------------------
 logical function isallmsr_2d(r)

 implicit none

 ! Passed variables
 real(kind_real),intent(in) :: r(:,:) ! Real

 isallmsr_2d = .not.isanynotmsr(r)

 end function isallmsr_2d

 !----------------------------------------------------------------------
 ! Function: isallmsr_3d
 ! Purpose: check if a real is set to missing value
 !----------------------------------------------------------------------
 logical function isallmsr_3d(r)

 implicit none

 ! Passed variables
 real(kind_real),intent(in) :: r(:,:,:) ! Real

 isallmsr_3d = .not.isanynotmsr(r)

 end function isallmsr_3d

 !----------------------------------------------------------------------
 ! Function: isallmsr_4d
 ! Purpose: check if a real is set to missing value
 !----------------------------------------------------------------------
 logical function isallmsr_4d(r)

 implicit none

 ! Passed variables
 real(kind_real),intent(in) :: r(:,:,:,:) ! Real

 isallmsr_4d = .not.isanynotmsr(r)

 end function isallmsr_4d

 !----------------------------------------------------------------------
 ! Function: isallmsr_5d
 ! Purpose: check if a real is set to missing value
 !----------------------------------------------------------------------
 logical function isallmsr_5d(r)

 implicit none

 ! Passed variables
 real(kind_real),intent(in) :: r(:,:,:,:,:) ! Real

 isallmsr_5d = .not.isanynotmsr(r)

 end function isallmsr_5d

 end module tools_missing
tools_missing::isanynotmsr
Definition: tools_missing.F90:79

tools_missing::isnotmsi_3d
logical function, dimension(max(size(i, 1), 1), max(size(i, 2), 1), max(size(i, 3), 1)) isnotmsi_3d(i)
Definition: tools_missing.F90:404

tools_missing::ismsi_1d
logical function, dimension(max(size(i), 1)) ismsi_1d(i)
Definition: tools_missing.F90:488

tools_missing::isnotmsi
Definition: tools_missing.F90:33

tools_missing::msi_4d
subroutine msi_4d(i)
Definition: tools_missing.F90:192

tools_missing::isnotmsr_3d
logical function, dimension(max(size(r, 1), 1), max(size(r, 2), 1), max(size(r, 3), 1)) isnotmsr_3d(r)
Definition: tools_missing.F90:640

tools_missing::isallmsi_3d
logical function isallmsi_3d(i)
Definition: tools_missing.F90:1219

tools_missing::isallmsr_2d
logical function isallmsr_2d(r)
Definition: tools_missing.F90:1354

tools_missing::isnotmsr_1d
logical function, dimension(size(r)) isnotmsr_1d(r)
Definition: tools_missing.F90:596

tools_missing::isanynotmsr_3d
logical function isanynotmsr_3d(r)
Definition: tools_missing.F90:994

tools_missing::msr_5d
subroutine msr_5d(r)
Definition: tools_missing.F90:312

tools_missing::isanymsi_2d
logical function isanymsi_2d(i)
Definition: tools_missing.F90:904

tools_missing::ismsi_5d
logical function, dimension(max(size(i, 1), 1), max(size(i, 2), 1), max(size(i, 3), 1), max(size(i, 4), 1), max(size(i, 5), 1)) ismsi_5d(i)
Definition: tools_missing.F90:560

tools_missing::isallmsr_5d
logical function isallmsr_5d(r)
Definition: tools_missing.F90:1399

tools_missing::isallmsr_4d
logical function isallmsr_4d(r)
Definition: tools_missing.F90:1384

tools_const::msvali
integer, parameter, public msvali
Definition: tools_const.F90:23

tools_missing::msr_6d
subroutine msr_6d(r)
Definition: tools_missing.F90:327

tools_missing::isanynotmsi_5d
logical function isanynotmsi_5d(i)
Definition: tools_missing.F90:874

tools_missing::isnotmsi_0d
logical function isnotmsi_0d(i)
Definition: tools_missing.F90:342

tools_missing::isallmsi_4d
logical function isallmsi_4d(i)
Definition: tools_missing.F90:1234

tools_missing::isallmsr
Definition: tools_missing.F90:114

tools_missing::isanynotmsi_1d
logical function isanynotmsi_1d(i)
Definition: tools_missing.F90:814

tools_missing::isanymsr
Definition: tools_missing.F90:86

tools_missing::msr_3d
subroutine msr_3d(r)
Definition: tools_missing.F90:282

tools_missing::msr_2d
subroutine msr_2d(r)
Definition: tools_missing.F90:267

tools_kinds
Definition: tools_kinds.F90:8

tools_missing::isallnotmsr_2d
logical function isallnotmsr_2d(r)
Definition: tools_missing.F90:1279

tools_missing::isallnotmsi_3d
logical function isallnotmsi_3d(i)
Definition: tools_missing.F90:1144

tools_missing::isallnotmsi
Definition: tools_missing.F90:93

tools_missing::ismsr_5d
logical function, dimension(max(size(r, 1), 1), max(size(r, 2), 1), max(size(r, 3), 1), max(size(r, 4), 1), max(size(r, 5), 1)) ismsr_5d(r)
Definition: tools_missing.F90:796

tools_missing::isallmsr_1d
logical function isallmsr_1d(r)
Definition: tools_missing.F90:1339

tools_missing::isanymsr_3d
logical function isanymsr_3d(r)
Definition: tools_missing.F90:1069

tools_missing::isallnotmsi_5d
logical function isallnotmsi_5d(i)
Definition: tools_missing.F90:1174

tools_const::msvalr
real(kind_real), parameter, public msvalr
Definition: tools_const.F90:24

tools_missing::ismsr_1d
logical function, dimension(size(r)) ismsr_1d(r)
Definition: tools_missing.F90:724

tools_missing::isnotmsr_4d
logical function, dimension(max(size(r, 1), 1), max(size(r, 2), 1), max(size(r, 3), 1), max(size(r, 4), 1)) isnotmsr_4d(r)
Definition: tools_missing.F90:662

tools_missing::ismsi_0d
logical function ismsi_0d(i)
Definition: tools_missing.F90:470

tools_missing::isallnotmsr_4d
logical function isallnotmsr_4d(r)
Definition: tools_missing.F90:1309

tools_missing::isanymsr_5d
logical function isanymsr_5d(r)
Definition: tools_missing.F90:1099

tools_missing::isanynotmsr_1d
logical function isanynotmsr_1d(r)
Definition: tools_missing.F90:964

tools_const
Definition: tools_const.F90:8

tools_missing::isanymsi_4d
logical function isanymsi_4d(i)
Definition: tools_missing.F90:934

tools_missing::ismsr
Definition: tools_missing.F90:57

tools_missing::isanynotmsi
Definition: tools_missing.F90:65

tools_missing::isanymsr_4d
logical function isanymsr_4d(r)
Definition: tools_missing.F90:1084

tools_missing::isnotmsi_1d
logical function, dimension(max(size(i), 1)) isnotmsi_1d(i)
Definition: tools_missing.F90:360

tools_missing::ismsr_4d
logical function, dimension(max(size(r, 1), 1), max(size(r, 2), 1), max(size(r, 3), 1), max(size(r, 4), 1)) ismsr_4d(r)
Definition: tools_missing.F90:778

tools_missing::isallnotmsr_1d
logical function isallnotmsr_1d(r)
Definition: tools_missing.F90:1264

tools_missing::isnotmsi_5d
logical function, dimension(max(size(i, 1), 1), max(size(i, 2), 1), max(size(i, 3), 1), max(size(i, 4), 1), max(size(i, 5), 1)) isnotmsi_5d(i)
Definition: tools_missing.F90:448

tools_missing::isanynotmsr_2d
logical function isanynotmsr_2d(r)
Definition: tools_missing.F90:979

tools_missing::isanynotmsr_5d
logical function isanynotmsr_5d(r)
Definition: tools_missing.F90:1024

tools_missing::msi_6d
subroutine msi_6d(i)
Definition: tools_missing.F90:222

tools_missing::msi_2d
subroutine msi_2d(i)
Definition: tools_missing.F90:162

tools_missing::isnotmsi_2d
logical function, dimension(max(size(i, 1), 1), max(size(i, 2), 1)) isnotmsi_2d(i)
Definition: tools_missing.F90:382

tools_missing::msr
Definition: tools_missing.F90:24

tools_missing::isnotmsi_4d
logical function, dimension(max(size(i, 1), 1), max(size(i, 2), 1), max(size(i, 3), 1), max(size(i, 4), 1)) isnotmsi_4d(i)
Definition: tools_missing.F90:426

tools_missing::isallnotmsi_2d
logical function isallnotmsi_2d(i)
Definition: tools_missing.F90:1129

tools_missing::isanynotmsr_4d
logical function isanynotmsr_4d(r)
Definition: tools_missing.F90:1009

tools_missing::isanymsr_2d
logical function isanymsr_2d(r)
Definition: tools_missing.F90:1054

tools_missing::msr_4d
subroutine msr_4d(r)
Definition: tools_missing.F90:297

tools_missing::ismsi_3d
logical function, dimension(max(size(i, 1), 1), max(size(i, 2), 1), max(size(i, 3), 1)) ismsi_3d(i)
Definition: tools_missing.F90:524

tools_missing::msi
Definition: tools_missing.F90:15

tools_missing::isanymsi_3d
logical function isanymsi_3d(i)
Definition: tools_missing.F90:919

tools_missing::isanymsi_5d
logical function isanymsi_5d(i)
Definition: tools_missing.F90:949

tools_missing::isallmsi_1d
logical function isallmsi_1d(i)
Definition: tools_missing.F90:1189

tools_missing::isanynotmsi_3d
logical function isanynotmsi_3d(i)
Definition: tools_missing.F90:844

tools_missing::ismsr_2d
logical function, dimension(max(size(r, 1), 1), max(size(r, 2), 1)) ismsr_2d(r)
Definition: tools_missing.F90:742

tools_missing::isallmsi
Definition: tools_missing.F90:100

tools_missing::msi_5d
subroutine msi_5d(i)
Definition: tools_missing.F90:207

size
************************************************************************GNU Lesser General Public License **This file is part of the GFDL Flexible Modeling System(FMS). ! *! *FMS is free software without even the implied warranty of MERCHANTABILITY or *FITNESS FOR A PARTICULAR PURPOSE See the GNU General Public License *for more details **You should have received a copy of the GNU Lesser General Public *License along with FMS If see< http:! ***********************************************************************subroutine READ_RECORD_CORE_(unit, field, nwords, data, start, axsiz) integer, intent(in) ::unit type(fieldtype), intent(in) ::field integer, intent(in) ::nwords MPP_TYPE_, intent(inout) ::data(nwords) integer, intent(in) ::start(:), axsiz(:) integer(SHORT_KIND) ::i2vals(nwords)!rab used in conjunction with transfer intrinsic to determine size of a variable integer(KIND=1) ::one_byte(8) integer ::word_sz!#ifdef __sgi integer(INT_KIND) ::ivals(nwords) real(FLOAT_KIND) ::rvals(nwords)!#else! integer ::ivals(nwords)! real ::rvals(nwords)!#endif real(DOUBLE_KIND) ::r8vals(nwords) pointer(ptr1, i2vals) pointer(ptr2, ivals) pointer(ptr3, rvals) pointer(ptr4, r8vals) if(mpp_io_stack_size< nwords) call mpp_io_set_stack_size(nwords) call mpp_error(FATAL, 'MPP_READ currently requires use_netCDF option') end subroutine READ_RECORD_CORE_ subroutine READ_RECORD_(unit, field, nwords, data, time_level, domain, position, tile_count, start_in, axsiz_in)!routine that is finally called by all mpp_read routines to perform the read!a non-netCDF record contains:! field ID! a set of 4 coordinates(is:ie, js:je) giving the data subdomain! a timelevel and a timestamp(=NULLTIME if field is static)! 3D real data(stored as 1D)!if you are using direct access I/O, the RECL argument to OPEN must be large enough for the above!in a global direct access file, record position on PE is given by %record.!Treatment of timestamp:! We assume that static fields have been passed without a timestamp.! Here that is converted into a timestamp of NULLTIME.! For non-netCDF fields, field is treated no differently, but is written! with a timestamp of NULLTIME. There is no check in the code to prevent! the user from repeatedly writing a static field. integer, intent(in) ::unit, nwords type(fieldtype), intent(in) ::field MPP_TYPE_, intent(inout) ::data(nwords) integer, intent(in), optional ::time_level type(domain2D), intent(in), optional ::domain integer, intent(in), optional ::position, tile_count integer, intent(in), optional ::start_in(:), axsiz_in(:) integer, dimension(size(field%axes(:))) ::start, axsiz integer ::tlevel !, subdomain(4) integer ::i, error, is, ie, js, je, isg, ieg, jsg, jeg type(domain2d), pointer ::io_domain=> tlevel if(PRESENT(start_in) .AND. PRESENT(axsiz_in)) then if(size(start(! the data domain and compute domain must refer to the subdomain being passed ! In this ! since that attempts to gather all data on PE size(field%axes(:)) axsiz(i)

tools_missing::isallnotmsr_5d
logical function isallnotmsr_5d(r)
Definition: tools_missing.F90:1324

tools_missing::isnotmsr_0d
logical function isnotmsr_0d(r)
Definition: tools_missing.F90:578

tools_missing::isanymsi
Definition: tools_missing.F90:72

tools_missing::isnotmsr_5d
logical function, dimension(max(size(r, 1), 1), max(size(r, 2), 1), max(size(r, 3), 1), max(size(r, 4), 1), max(size(r, 5), 1)) isnotmsr_5d(r)
Definition: tools_missing.F90:684

tools_missing::msi_0d
subroutine msi_0d(i)
Definition: tools_missing.F90:132

tools_missing::isallmsi_2d
logical function isallmsi_2d(i)
Definition: tools_missing.F90:1204

tools_missing::isanymsr_1d
logical function isanymsr_1d(r)
Definition: tools_missing.F90:1039

max
#define max(a, b)
Definition: mosaic_util.h:33

tools_missing::isallnotmsr_3d
logical function isallnotmsr_3d(r)
Definition: tools_missing.F90:1294

tools_missing::ismsr_3d
logical function, dimension(max(size(r, 1), 1), max(size(r, 2), 1), max(size(r, 3), 1)) ismsr_3d(r)
Definition: tools_missing.F90:760

tools_missing::isallnotmsi_1d
logical function isallnotmsi_1d(i)
Definition: tools_missing.F90:1114

tools_missing::msr_0d
subroutine msr_0d(r)
Definition: tools_missing.F90:237

tools_missing::ismsi
Definition: tools_missing.F90:41

tools_missing::msi_1d
subroutine msi_1d(i)
Definition: tools_missing.F90:147

tools_missing::isallmsi_5d
logical function isallmsi_5d(i)
Definition: tools_missing.F90:1249

tools_missing::isanymsi_1d
logical function isanymsi_1d(i)
Definition: tools_missing.F90:889

tools_missing
Definition: tools_missing.F90:8

tools_missing::msr_1d
subroutine msr_1d(r)
Definition: tools_missing.F90:252

tools_missing::isanynotmsi_2d
logical function isanynotmsi_2d(i)
Definition: tools_missing.F90:829

fv3jedi_kinds_mod::kind_real
integer, parameter, public kind_real
Definition: fv3jedi_kinds_mod.f90:13

tools_missing::isanynotmsi_4d
logical function isanynotmsi_4d(i)
Definition: tools_missing.F90:859

tools_missing::msi_3d
subroutine msi_3d(i)
Definition: tools_missing.F90:177

tools_missing::isallnotmsr
Definition: tools_missing.F90:107

tools_missing::ismsi_4d
logical function, dimension(max(size(i, 1), 1), max(size(i, 2), 1), max(size(i, 3), 1), max(size(i, 4), 1)) ismsi_4d(i)
Definition: tools_missing.F90:542

tools_missing::isallmsr_3d
logical function isallmsr_3d(r)
Definition: tools_missing.F90:1369

tools_missing::isnotmsr_2d
logical function, dimension(max(size(r, 1), 1), max(size(r, 2), 1)) isnotmsr_2d(r)
Definition: tools_missing.F90:618

tools_missing::ismsr_0d
logical function ismsr_0d(r)
Definition: tools_missing.F90:706

tools_missing::isallnotmsi_4d
logical function isallnotmsi_4d(i)
Definition: tools_missing.F90:1159

tools_missing::ismsi_2d
logical function, dimension(max(size(i, 1), 1), max(size(i, 2), 1)) ismsi_2d(i)
Definition: tools_missing.F90:506

tools_missing::isnotmsr
Definition: tools_missing.F90:49