# Fortran/complex types

## Introduction[edit]

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.

## Declaration[edit]

The standard way to declare a complex number is simply using the `COMPLEX`

statement:

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[edit]

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 `(0.0,1.0)`

, `2-3`

, and 1000000000*i* as (2.0,-3.0)*i* 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 `(1.0D+00,0.0D+00)`

, `(0.0D+00,1.0D+00)`

, `(2.0D+00,-3.0D+00)`

, and `(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 `CMPLX`

function:

CMPLX(a, b)

Any expression involving complex numbers and other numbers is promoted to complex.

## Operators and Functions[edit]

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.