Robert Kernell writes:
 > Hi. I am teaching a Fortran class and I was wondering...
 > 
 > Is there any use for specifying kinds for constants?

Absolutely.  You have to specify the kind any time that you need
a non-default kind.  For reals, you can alternatively specify
double precision in cases where that is appropriate.  That's
a way of specifying a kind - I'm not sure from the question whether
you are talking about specifying kinds at all or whether you are
talking about the distnction between specifying double precision
using the kind syntax vs the double precision syntax.

If you are questioning whether one needs to specify kinds at all
(whether by kind syntax or double precision syntax), then the answer
is that it is very important in many applications.  The value

  3.14159265358979323846264338327950

is single precision, independent of the number of digits written (and
independent on whether I remembered them all correctly).  If you
expected more precision, then you better say so, either by using kind
or double precision syntax.  Otherwise you'll likely have an
unexpected precision loss.  Or, if you do something like pass this as
an actual argument to a subroutine expecting a different kind, it is
likely to produce complete gibberish (likely off by a few hundred
orders of magnitude).

I would be a serious mis-service to students to give them the
impression that kinds can often be ignored.  This quite often
results in code that either doesn't compile at all, gives garbage
results, or just gives results with far less precision than
expected and required.  One should instead take it as the default
assumption that the kind *USUALLY* matters unless you are in a
context where you know that it doesn't.  Its easier to describe
the contexts where it doesn't matter than those where it does.
For the kind of a constant not to matter, you need two conditions

1. It must be in a context where any kind is allowed.  Generally
   this means contexts where the value will automatically be
   converted to the appropriate kind.  This would include things
   like operands to arithmetic operations, or the right hand
   side of assignment statements.

2. The value must either be one whose precision doesn't matter
   to the application or one that you know to be exactly representable
   in the lower precision.  (The standard doesn't actually guarantee
   that any floating point values are exactly representable, but in
   practice it is very safe to assume that small values with no
   fractional part are exactly representable).  There are certainly
   plenty of cases where a loss of precision doesn't really matter.
   (If I ask for a label on a plot to be written in characters 0.2
   inches high, I really don't care at all if they end up as
   0.200007).

If *EITHER* of these conditions fails to hold, then kind matters.

(I've neglected range here.  It can matter for some things - though
it's not as often an issue as precision is for reals.  And I've also
concentrated on reals - approximations aren't an issue with integers,
but range often is).

If you are asking about the distinction between using kind syntax
versus double precision syntax, that is mostly a matter of
portability, and it has little to do with constants in particular.
The same question applies to variable declarations.  If you use
kind syntax, you can make the code portable among machines of
different precisions.  If you just use double precision on a
32-bit workstation, you'll likely find that is not what you really
want when you port the code to a Cray.

Of course, just using either syntax doesn't magically make your code
easy to port or not, any more than avoiding GOTO statements magically
makes your code well-structured.  It is quite possible to write code
using kind syntax that won't port easily at all.  Hard-wiring explicit
kind numbers would be a good start - doing arithmetic with kind
numbers would make it worse.  It is also possible to write f77-style
code with sufficient care so that it is a simple global edit to port
the code to machines of different precisions - I used to do that, as
did plenty of other people.

The difference is that the kind syntax facilitates portability,
whereas with single/double precision, you are depending completely
on programmer conventions (and the programmer had better have a
pretty well thought out set of them).

Plus kind syntax supports more than 2 precisions.  The vendor
extensions to do so with other syntaxes are not particularly
good about portability.

If your students are likely to be writing libraries that use generics
to support multiple precisions, then life is a bit more complicated,
as has been discussed here before.  But generally, there are a lot
more users of such libraries than writers of them (one would hope).

-- 
Richard Maine
[log in to unmask]



%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%