On Tue, Jul 25, 2017 at 9:56 PM, Malcolm Cohen <[log in to unmask]> wrote:
>..
>
> But there are NO processors which implement SAME_TYPE_AS as distinguishing between kinds for all types (as SELECT TYPE does). Not a single one. That is because the standard requires them not to distinguish between kinds for derived types.
>..
Separately I am taken aback by above statements, both as a matter of
accuracy (in a couple of ways of looking at them) and the consequent
relevance.
Is it not first that the standard with its sentence, "If neither A nor
B has extensible dynamic type, the result is processor dependent."
leave it up to the processor to decide whether to return true of false
as the result of the inquiry? Which would be quite a bit different
from saying, "standard requires them not to distinguish between kinds
for derived types".
Also, "there are NO processors which implement SAME_TYPE_AS as
distinguishing between kinds for all types" - really? Intel Fortran
seems to distinguish between kinds in every type I can conceive. You
have already seen the earlier example involving REAL types (which
readers can check out with other intrinsic types), now see another one
with derived types below. Can someone point out some kinds of types
that Intel Fortran fails to distinguish?
------- begin test code --------
implicit none
type :: foo(k)
integer, kind :: k
end type
type, bind(C) :: bar
end type
type :: foobar
sequence
end type
blk1: block
class(*), allocatable :: x
class(*), allocatable :: y
allocate( foo(k=1) :: x )
allocate( foo(k=1) :: y )
print *, "block 1"
print *, "same_type_as(foo(k=1) :: x, foo(k=1) :: y) = ",
same_type_as(x,y)
print *, "expected output is T", new_line("")
end block blk1
blk2: block
class(*), allocatable :: x
class(*), allocatable :: y
allocate( foo(k=1) :: x )
allocate( foo(k=2) :: y )
print *, "block 2"
print *, "same_type_as(foo(k=1) :: x, foo(k=2) :: y) = ",
same_type_as(x,y)
print *, "expected output is F", new_line("")
end block blk2
blk3: block
class(*), allocatable :: x
class(*), allocatable :: y
allocate( bar :: x )
allocate( bar :: y )
print *, "block 3"
print *, "same_type_as(bar :: x, bar :: y) = ", same_type_as(x,y)
print *, "expected output is T", new_line("")
end block blk3
blk4: block
class(*), allocatable :: x
class(*), allocatable :: y
allocate( foobar :: x )
allocate( foobar :: y )
print *, "block 4"
print *, "same_type_as(foobar :: x, foobar :: y) = ", same_type_as(x,y)
print *, "expected output is T", new_line("")
end block blk4
blk5: block
class(*), allocatable :: x
class(*), allocatable :: y
allocate( bar :: x )
allocate( foobar :: y )
print *, "block 5"
print *, "same_type_as(bar :: x, foobar :: y) = ", same_type_as(x,y)
print *, "expected output is F", new_line("")
end block blk5
blk6: block
use, intrinsic :: iso_c_binding, only : c_ptr
class(*), allocatable :: x
class(*), allocatable :: y
allocate( c_ptr :: x )
allocate( c_ptr :: y )
print *, "block 6"
print *, "same_type_as(c_ptr :: x, c_ptr :: y) = ", same_type_as(x,y)
print *, "expected output is T", new_line("")
end block blk6
blk7: block
use, intrinsic :: iso_c_binding, only : c_ptr
class(*), allocatable :: x
class(*), allocatable :: y
allocate( c_ptr :: x )
allocate( bar :: y )
print *, "block 7"
print *, "same_type_as(c_ptr :: x, bar :: y) = ", same_type_as(x,y)
print *, "expected output is F", new_line("")
end block blk7
end
------- end test code --------
Upon execution, the program gives
-------- begin output -----------
block 1
same_type_as(foo(k=1) :: x, foo(k=1) :: y) = T
expected output is T
block 2
same_type_as(foo(k=1) :: x, foo(k=2) :: y) = F
expected output is F
block 3
same_type_as(bar :: x, bar :: y) = T
expected output is T
block 4
same_type_as(foobar :: x, foobar :: y) = T
expected output is T
block 5
same_type_as(bar :: x, foobar :: y) = F
expected output is F
block 6
same_type_as(c_ptr :: x, c_ptr :: y) = T
expected output is T
block 7
same_type_as(c_ptr :: x, bar :: y) = F
expected output is F
-------- end output -----------
Thanks,
Vipul Parekh
|
