In most languages, "complex" means some sort of structured data type. In Fortran, there are no structures of that ilk. There are however, what we call in mathematics, "complex numbers". A complex number has a real and an imaginary component. In Fortran, complex numbers are stored as a pair of real numbers (real part first, followed by the imaginary part), or a pair of double-precision numbers.
For something resembling structures, see Common Blocks.
The standard way to declare a complex number is simply using the
COMPLEX myVariable, anotherVariable, anArray(2,3)
This is equivalent on most systems to specifying a length of 8 (two 4-byte Reals):
COMPLEX*8 myVariable, anotherVariable, anArray(2,3)
If you want double-precision complex numbers, you're pretty much stuck with specifying a precision, and hoping that the compiler likes that format. Here's where portability comes in: If, for instance, the machine has floating point types of lengths 4, 8, and 16, and I specify a complex length of 8, 16, or 32, I'm likely to get a pair of floating point numbers at the size I expect. If, however, I specify a length of some other value, for instance, 10, then I'm likely to get a pair of 4s or 8s, depending on what the compiler likes to do. So, in general, to get the values as double-precision, I'd code:
COMPLEX*16 myVariable, anotherVariable, anArray(2,3)
Constants and Expressions
Complex constants are specified as
(, a real value, a comma, another real value, and
). Some examples are 1 as
(1.0,0.0), i as
2-3i as (2.0,-3.0), and 1000000000i as
(0.0,1.0E+09). The same constants can be coded as double-precision complex constants by the simple expedient of using a
D in the exponent. Thus, the same constants can be coded in double-precision using
(0.0D+00,1.0D+09), respectively. Note: This notation cannot be used with variables. For example,
(a, b) is invalid. To convert real variables to complex, use the
Any expression involving complex numbers and other numbers is promoted to complex.
Operators and Functions
All of the arithmetic operators can take a complex number on either side.
Care must be taken in using function calls that might cause an error. For instance, taking the square root of the real number -1 (coded as
-1.0) will result in an error, because -1 is outside of the domain of real square root. Taking the square root of the complex number -1 (coded as
(-1.0,0.0)) is OK, because -1 is in the domain of complex square root.