Re: Ambiguous interfaces

From: Rich Townsend (rhdt_at_barVOIDtol.udel.edu)
Date: 03/02/04 

Date: Tue, 02 Mar 2004 10:25:09 -0500

Stig Kildegård Andersen wrote:
> Hello all,
>
> I have a question about ambiguous interfaces. Is the following code standard
> conforming or broken, if kind number 8 is supported by the compiler and if
> it is the deault integer kind?
>
> If the code is broken (I assume that it is): Is there any other way to use
> generic interfaces for subroutines that operate on different kinds of
> integers, where, in some cases, the kind numbers are identical?
>
> Kind Regards and Thank You in advance,
> Stig Kildegård Andersen
>
> !-------------
>
> module MyModule
> implicit none
>
> integer, parameter :: BigIntegerKind = 8
>
> interface DoSomething
> module procedure DoSomething_DefaultInteger
> module procedure DoSomething_BigInteger
> end interface
>
> contains
>
> subroutine DoSomething_DefaultInteger(argument)
> integer, intent(in) :: argument
> write(*,*) argument
> end subroutine
>
> subroutine DoSomething_BigInteger(argument)
> integer(kind=BigIntegerKind), intent(in) :: argument
> write(*,*) argument
> end subroutine
>
> end module
>
> !-------------
>
> program ambiguous
> use MyModule
> implicit none
>
> integer :: MyInteger = 0
>
> write(*,*) kind(1), kind(1_BigIntegerKind)
> call DoSomething(MyInteger)
>
> end program
>

Apart from the fact that you should try to avoid using hard-coded kind
parameters (use SELECTED_*_KIND instead), you are correct in your
supposition. Basically, if you combine two or more specific routines
into a generic routines, and the kind parameters happen to be identical
(in a platform-dependent sort of way), then your program becomes
non-conforming.

This is something I've thought long and hard about. In many of my
libraries, I have generic interfaces to routines which operate at
default real precision and at double precision. However, on a 64-bit
platform the double precision routines may well end up as 128-bit
floats, which is overkill. Therefore, it would be better to program my
"single" and "double" precision specific routines as "32-bit real" and
"64-bit real" precision routines, by use of appropriate
SELECTED_REAL_KIND calls.

However, then I run into the problem Stig has pointed out. What then
happens when on a 64-bit platform SELECTED_REAL_KIND assigns me the same
kind paramter for my 32-bit real and 64-bit real routines? Then, my
routines will appear identical when combined into a generic, and my
program won't be conforming anymore.

The essence of the problem is that SELECTED_REAL_KIND gives a kind
parameter with at least the precision/range requested, but there is no
hard upper limit on the precision/range -- only, AFAIK, a requirement to
chose the one with the least decimal precision, if more than one kind is
available.

The only way I've come up with to solve this "kind collision" problem is
through conditional compilation. Anyone else have any thoughts?

cheers,

Rich

PS Yes, I know that I shouldn't be talking about 32-bit and 64-bit, but
instead should be referring to the range etc of my number models. But
the bit nomenclature is easier to remember...

PPS Its worth mentioning that I've never encountered this kind collision
in real-world situations; but its also worth mentioning that I'm only
just starting to port my libraries to 64-bit platforms.

Relevant Pages

  • Re: high-precision eigenvalue solver
    ... >> precision. ... Rather than hand-coding the routines, I would use a package like Gnu ... and recode the lapack routines to call the ... Since it's quadratically convergent, this isn't as ...
    (sci.math.num-analysis)
  • Re: qfloat extended precision in Cephes library
    ... for Mathematical Functions (Ellis Horwood Series in Mathematics and Its ... precision offering in particular. ... qfloat.h C++ wrapper makes it easier to write math code that looks like ... Some of Mr. Moshier's built-in routines, ...
    (sci.math.num-analysis)
  • Re: Maples linear algebra routine and higher precision arithmetic
    ... precision results with results generated by increasing levels of precision. ... Sometime ago I recall hearing that Maple was changing that way it dealt ... with linear algebra routines --- maybe by using NAG routines ... Digits. ...
    (sci.math.symbolic)
  • Re: Maples linear algebra routine and higher precision arithmetic
    ... precision results with results generated by increasing levels of precision. ... with linear algebra routines --- maybe by using NAG routines ... Digits. ... meaning that hardware is used if Digits <= evalhf(i.e. ...
    (sci.math.symbolic)
  • Re: Whats the purpose of explicit interfaces?
    ... include file and allow the described routines to include the definitions ... to verify them, as in C. ... explicit interfaces created automatically. ... In this case the compiler can check that the ...
    (comp.lang.fortran)