2-3 DATA TYPES
***************
(Thanks to Craig Burley for the excellent comments)
The star notation
-----------------
The 'star' (*n) notation is standard Fortran for character strings,
using the star notation for non-character (numeric) data-types is
common, but not standard Fortran, either FORTRAN 77 or Fortran 90.
The Fortran standards can't allow the star notation because they
must avoid any restriction on the internal representation of variables,
otherwise Fortran programs will not be portable to machines with
different architectures.
The number after the star in character strings is the number of
"character storage units", whose size is purposely left undefined
and is never compared with the "numeric storage unit" used to
describe numeric types. The number of "character storage units"
is the number of characters in the string, not the number of bytes.
Almost all "English speaking" computers use one-byte representations
for characters, so the number after the star coincide with the
number of bytes used in the internal representation. In the
non-standard use of the star notation for numeric data types,
the number after the star also denotes the number of bytes used.
The basic data types
--------------------
The data types provided by a language have little to do with the
underlying machine, there were perfectly usable Fortran compilers
on 8-bit computers, which simulated 32-bit floating point hardware.
The basic data types of FORTRAN 77 are: integers, floating-point
numbers of two kinds (REAL and DOUBLE PRECISION), logicals and
character strings.
In FORTRAN 77, the only allowed method of creating compound data
types out of the basic types is forming arrays.
Character strings
-----------------
The term 'character' became a little vague, due to widespread
confusion between the objects themselves and their representations.
A character is a graphic sign (glyph) that may be represented
differently in different representation schemes developed and
used on different machines.
Individual characters (CHARACTER*1) are always represented in
practise as small integers, usually in the range 0-255 so they
can be stored in one byte (see Appendix B and the terminals and
printers chapter).
The exceptions to the 'one byte per character rule' are:
1) Unicode systems - characters are consistently
16-bits per character.
2) asian language systems - the number of bytes
per character is variable.
Because characters are represented, in practice, always as small
integers, and representations are what computers use and work with,
people sometimes tend to think that the integer representation is
the primary entity.
You will often hear people referring to characters as if the graphic
sign is assigned to the representation, e.g. 'character 32 is SPACE',
instead of 'SPACE is represented by 32 in the ASCII scheme'.
In most computers the translation between characters and numbers
is made according to the ASCII scheme. There are other schemes like
EBCDIC on IBM computers - in that scheme the decimal digits and the
letters doesn't have successive values (see Appendix B).
Different extensions of the ASCII scheme are discussed in the
chapter on terminals and printers.
Individual characters can be combined to form character arrays and
character strings.
BYTE
----
A NONSTANDARD fortran data type, equivalent to C 'signed char'.
Can be thought of as a small subtype of INTEGER, formally equivalent
to LOGICAL*1, which is also nonstandard fortran.
Should be used only if you have to do fast byte manipulations on data.
Size: 1 byte (8 bits)
Value range: -128 to 127.
INTEGER
-------
The data given here is "typical", but not standard or ubiquitous.
the standard INTEGER data type was implemented as INTEGER*2 on old
16 bit machines, it is now usually INTEGER*4, but on the new 64 bit
machines (and some older ones) it may be an INTEGER*8.
For more information on integer representations see the chapter
on integers.
FORTRAN integer types are signed:
INTEGER*2 (non-standard)
------------------------
Size: 2 bytes (16 bits, bit 15 = sign)
Value range: -32768 to 32767
INTEGER*4
---------
Size: 4 bytes (32 bits, bit 31 = sign)
Value range: -2147483648 to 2147483647
INTEGER*4 can be thought of as an extended INTEGER*2 -
if the value lies in the INTEGER*2 range, then the first
(little-endian machine) or last (big-endian machine) two
bytes can be referenced as an INTEGER*2
INTEGER*8
---------
Similar to INTEGER*4 but with larger range.
Found on 64 bit machines and on 32-bit machines such as SPARC.
REAL and DOUBLE PRECISION
-------------------------
The standard REAL and DOUBLE PRECISION data types may be implemented
differently on different machines.
Usually REAL is 4 bytes long and DOUBLE precision is 8 bytes long,
on CRAYs they are 8 and 16 bytes long respectively, but not all bytes
are used.
See the section on Floating-Point Numbers for an elementary
introduction to the subject and information on various aspects.
LOGICAL
-------
The FORTRAN standard requires logical variables to be the same size
as INTEGER/REAL variables (see the chapter on memory management)
although only one bit is really needed to implement this type.
The values used to implement the logical constants .TRUE. and
.FALSE. differ:
| VMS | Sun | IRIX |
-----------|------------|-----------|-----------|-----------
.TRUE. | -1 | 1 | 1 |
-----------|------------|-----------|-----------|-----------
.FALSE. | 0 | 0 | 0 |
-----------|------------|-----------|-----------|-----------
Unix machines naturally adopted the C convention, VMS has a seemingly
strange value for .TRUE., however on a closer look you will see that
if .FALSE. is "all bits 0", .TRUE. should be "all bits 1", in two's
complement signed integers the number with all bits set to 1 is -1.
Return to contents page