Complex constants and variables

Inspired by the redundant parentheses thread, I looked up the rules for complex literals.

If both parts of the literal constant are of type real, the kind type parameter of the literal constant is the kind parameter of the part with the greater precision, and the kind type parameter of the part with lower precision is converted to that of the other part.

If both parts are of type integer, they are each converted to type default real. If one part is of type integer and the other is of type real, the integer is converted to type real with the precision of the real part.

They surprised me. Good tweet material :slight_smile: . Here is an illustrative program.

program complex_numbers
implicit none
integer, parameter :: dp = kind(1.0d0)
real :: r1=2.0, r2 = 3.0
real, parameter :: c1 = 2.0, c2 = 3.0
real(kind=dp), parameter :: d1 = 2.0_dp, d2 = 3.0_dp
! line below invalid since r1 and r2 are not constants
! print*,(r1,r2) 
print*,"(2,3)",(2,3),"integers converted to default real in complex constructor"
print*,"(2,3.0)",(2,3.0),"both parts of complex number are default real"
print*,"(2.0d0,3.0)",(2.0d0,3.0),"both parts have the higher precision"
print*,"cmplx(r1,r2)",cmplx(r1,r2),"complex number where the real and imaginary parts are variables"
print*,"cmplx(d1,d2)",cmplx(d1,d2),"single precision complex number, because no kind specified!"
print*,"cmplx(d1,d2,kind=dp)",cmplx(d1,d2,kind=dp),"double precision complex number"
end program complex_numbers


 r1,r2 2.00000000  3.00000000 
 c1,c2 2.00000000  3.00000000 
 d1,d2 2.0000000000000000  3.0000000000000000  
 (c1,c2)  (2.00000000,3.00000000)
 (2.0,3.0)  (2.00000000,3.00000000)
 (2,3)  (2.00000000,3.00000000) integers converted to default real in complex constructor
 (2,3.0)  (2.00000000,3.00000000) both parts of complex number are default real
 (2.0d0,3.0)  (2.0000000000000000,3.0000000000000000) both parts have the higher precision
 cmplx(r1,r2)  (2.00000000,3.00000000) complex number where the real and imaginary parts are variables
 cmplx(d1,d2)  (2.00000000,3.00000000) single precision complex number, because no kind specified!
 cmplx(d1,d2,kind=dp)  (2.0000000000000000,3.0000000000000000) double precision complex number
1 Like

which leads to this interesting result. you can construct con3 from con1 and con2
and use it to define a complex constant, but if you put the expression used to create
con3 into the definition of a complex constant (cx2) it is non-standard; which is a little
non-intuitive but correct; even though some compilers allow it, so if you want to use an expression to create the constant, you have to define it as a literal constant first of say, type real; where you can use an expression (as in the definition of con3).

program testit
real,parameter :: con1=10.0, con2=20.0
real,parameter :: con3=con1*con2
complex :: cx1=(con3,30.0)
!!complex :: cx2=(con1*con2,30.0) ! bad: gfortran, ifort; good: nvfortran
end program testit

A better illustration perhaps is


program testit
! bad: gfortran, ifort; good: nvfortran
complex :: cx2=(sin(40.0),cos(40.0)) 
end program testit


program testit
real,parameter :: r1=sin(40.0), r2=cos(40.0)
complex :: cx2=(r1,r2)
end program testit


So what will this do (hint: depends on which standard level)?

program testit
complex :: cx2=cmplx(sin(40.0),cos(40.0)) 
end program testit

It will be default complex value in F2003+. Before that, elemental intrinsic functions with non-integer/non-character arguments/results were forbidden in initializers.

Which one(s) did? The rules are pretty standard, conforming to what is being done when two arguments of different types/kinds meet in an arithmetic operation.

The only thing which might seem surprising is (in your snippet, not in the conversion rules) the result of
cmplx(d1,d2) being default complex. But cmplx is a conversion function, analogous to real, coming from times of F77 Standard in which there was no kind or double precision complex type. Accordingly, there was REAL()/DBLE() pair but only CMPLX().

1 Like

Nice summary from my view. I always have to double-check cmplx() calls have a kind parameter if not using default real; and until I found someone else using it it had not occurred to me cmplx could take just one value. So I have been surprised by

program testit
write(*,*)cmplx(10)  ! did not know a single value was legal for a long time
write(*,*)cmplx(20.0d0,20.0d0) ! had to learn this returns default real kind
write(*,*)(20.0d0,20.0d0)  ! and so was not sure this would return double
end program testit

and I think %im and %re were around for a long time before I knew it, and even longer before I knew they would be used on the LHS; although I am not sure that is a common miss.


those were my personal surprises. I hate cmplx() defaulting to default real enough I was using my own generic function just called COMPLEX for a while; but it ends up some compilers have a procedure of the same name, and so it was confusing.

It was so in F77 (or, maybe, earlier). As it is a type conversion function, it could always take any arithmetic type argument. One (then the imaginary part was set to 0.0) or two, with the obvious exception of only single complex argument allowed.

I always specify the second value, perhaps a quirk but I prefer to. I (think) I know the rules now, but I do remember some struggles with complex values. Hard to remember them all now but for a tweet there might be some fodder here:

program testit
integer,parameter :: dp=kind(0.0d0)
complex :: c1
real(kind=dp) :: d1=100.0d0, d2=200.0d0
complex(kind=dp) :: c2(3)

write(*,*)cmplx(10) ! one value is allowed

write(*,*)cmplx(20.0d0,20.0d0) ! this is default kind
write(*,*)cmplx(20.0d0,20.0d0,kind=dp) ! this gets doubleprecision
! this gets doubleprecision using %kind if compiler has this yet

c1=(30,40)  ! allowed with constants
!c2=(d1,d2) ! but cannot do this
c1=(20+3) ! but you can do this because it is an expression 
          ! and () is actually not defining a complex value. It is the same as "c1=20+3"

c1%re=d1; c1%im=d2
write(*,'(g0,"+i",g0)')c1 ! you have to define two fields for complex
write(*,*) c1  ! note the parenthesis
write(*,'(g0)') ! g0 and * produce very different results with complex, unlike with most other values

end program testit

Your descriptions are great, by the way. WIsh some textbooks were as clear.

1 Like