Implicit conversion between single and double precision real

[MinsukJi-NOAA]

For the following subroutine:

subroutine test(a_in)
  class(*), intent(in) :: a_in
  real :: a_local
  ...
  select type (a_in)
  type is (real(4))
    a_local = a_in        ! case 1
  type is (real(8))
    a_local = a_in        ! case 2
  end select
  ...
end subroutine

There are 4 possible scenarios:

1. test is compiled in single precision and the passed argument a_in is a single precision real. This is okay because case 1 will occur with no conversion.
2. test is compiled in double precision and the passed argument a_in is a double precision real. This is okay because case 2 will occur with no conversion.
3. test is compiled in single precision and a_in is a double real. Case 2 will occur with implicit conversion from double to single
4. test is compiled in double precision and a_in is a single real. Case 1 will occur with implicit conversion from single to double

First question: Are both 3) and 4) acceptable?

Second question: Is there an advantage for going the extra mile to check the type of a_local and use DBLE or SNGL function for explicit conversion?

[rem1776]

For question 1, I would say 3 and 4 depend on the routine it's being used in. As long as the subroutine and any subsequent calls in it will not be affected by the possible loss/gain in precision it should be fine, but it's probably better to use explicit types on bigger routines to keep any values from changing.

For question 2, the explicit conversions are more of a best practice since it makes it easier to see where the conversions are occurring, so it might be good to add it in a case like this where the value could change. The REAL function can also be used to convert to whatever the default real size is, so that could be used without checking a_local's type.