problem: linux ifort 64 bits returns NaN on Ubuntu 64 bits

[fassisalmeida]

(sorry my english. it isn't too good)
My OS is Ubuntu 7.10 64 bits and my CPU is a Intel Core 2 Duo (T5250).
I have installed ifort 64 bits (l_fc_p_10.1.012_intel64.tar.gz) on my PC.

I compile a code *.f use the command.
$ ifort -o test *.f

and run with
$ ./test
NaN 9.9999998E-03
NaN 1.9801980E-04

----------------------------------------------


I can't understand NaN result because when I use Ubuntu 7.10 32 bits and I run the same code compiled by ifort 32 bits (same PC) (l_fc_p_10.1.012_ia32) the result is

$ ./test
9.8724573E-03 9.9999998E-03
1.9951592E-03 1.9801980E-04

----------------------------------------------


Are there something wrong with my code or my compilation on a 64 bits system?

The are only 3 codes in the directory of compilation. These codes are:

__________________________________________________________________

c Main program --> testegmacue.f
IMPLICIT NONE
INTEGER SEED,I,N,M, tempo
REAL SOMA2,SOMA4
COMPLEX U(100,100)

N = 100
M = 6000

CALL SYSTEM_CLOCK(SEED)
tempo = seed

SEED = 10*ABS(COS(FLOAT(SEED)))

CALL RANSET(SEED)

SOMA2 = 0
SOMA4 = 0
DO I = 1,M
SEED = SEED + 1
CALL GMACUE(N,U,SEED)
SOMA2 = SOMA2 + CABS(U(1,2))**2
SOMA4 = SOMA4 + CABS(U(1,2))**4
END DO
WRITE(*,*) SOMA2/M, 1./N
WRITE(*,*) SOMA4/M, 2./(N*(N+1))

END
_____________________________________________________________________

c gmacue.f
SUBROUTINE GMACUE(N,U,SEED)
IMPLICIT NONE
INTEGER SEED,N,I,J,IA,JA
COMPLEX U(N,N)
REAL FI,CHI,PSI,RANF
REAL PI
COMPLEX IM
COMPLEX C1,C2
IM = (0,1)
PI = 3.14159
CALL RANSET(SEED)

DO IA=1,N
DO JA=1,IA-1
U(IA,JA) = 0
END DO
U(IA,IA) = 1
DO JA=IA+1,N
U(IA,JA) = 0
END DO
END DO

DO I = N-1,1,-1
DO J = I+1,N-1
FI = 2*(N - J + 1)
FI = 1./FI
FI = ACOS(RANF()**FI)
PSI = 2*PI*RANF()
C1 = COS(FI)*CEXP(IM*PSI)
C2 = SIN(FI)
CALL SMATMUL(U,N,I,J,C1,C2)
END DO
FI = ACOS(RANF()**0.5)
PSI = 2*PI*RANF()
CHI = 2*PI*RANF()
C1 = COS(FI)*CEXP(IM*PSI)
C2 = SIN(FI)*CEXP(IM*CHI)
CALL SMATMUL(U,N,I,N,C1,C2)
END DO
C1 = CEXP(IM*2*PI*RANF())
DO I = 1, N
DO J = 1,N
U(I,J) = U(I,J)*C1
END DO
END DO
RETURN
END

SUBROUTINE SMATMUL(A,N,I,J,C1,C2)
IMPLICIT NONE
INTEGER K,N,I,J
COMPLEX A(N,N),C1,C2,AKI

DO K = 1,N
AKI = A(K,I)
A(K,I) = C1*AKI - CONJG(C2)*A(K,J)
A(K,J) = CONJG(C1)*A(K,J) + C2*AKI
END DO

RETURN
END

______________________________________________________________________

**==ranf.spg processed by SPAG 4.52O at 11:03 on 18 Oct 1996

FUNCTION RANF()
IMPLICIT NONE
DOUBLE PRECISION RANF
REAL*8 RCARRY
RANF = DBLE(RCARRY())
RETURN
C ----------------------------------------------------C
END
**==randx.spg processed by SPAG 4.52O at 11:03 on 18 Oct 1996

FUNCTION RANDX(Iseed)
C----------------------------------------------------------------------C
C Random number generator, fast and rough, machine independent.
C Returns an uniformly distributed deviate in the 0 to 1 interval.
C This random number generator is portable, machine-independent and
C reproducible, for any machine with at least 32 bits / real number.
C REF: Press, Flannery, Teukolsky, Vetterling, Numerical Recipes (1986)
C----------------------------------------------------------------------C
IMPLICIT NONE
INTEGER IA, IC, Iseed, M1
REAL*8 RANDX, RM
PARAMETER (M1=714025, IA=1366, IC=150889, RM=1.D+0/M1)
c
Ise ed = MOD(IA*Iseed+IC, M1)
RANDX = Iseed*RM
IF (RANDX.LT.0.D+0) THEN
STOP '*** Random number is negative ***'
END IF
c
RETURN
END
**==ranset.spg processed by SPAG 4.52O at 11:03 on 18 Oct 1996

SUBROUTINE RANSET(Iseed)
IMPLICIT NONE
INTEGER Iseed

CALL RSTART(Iseed)
RETURN
END
**==rstart.spg processed by SPAG 4.52O at 11:03 on 18 Oct 1996

SUBROUTINE RSTART(Iseeda)
C----------------------------------------------------------------------C
C Initialize Marsaglia list of 24 random numbers.
C----------------------------------------------------------------------C
IMPLICIT NONE
REAL*8 CARRY, ran, RANDX, SEED
INTEGER i, I24, ISEED, Iseeda, J24
COMMON /RANDOM/ SEED(24), CARRY, I24, J24, ISEED

I24 = 24
J24 = 10
CARRY = 0.D+0
ISEED = Iseeda
c
c get rid of initial correlations in rand by throwing
c away the first 100 random numbers generated.
c
DO i = 1, 100
ran = RANDX(ISEED)
END DO
c
c initialize the 24 elements of seed
c

DO i = 1, 24
SEED(i) = RANDX(ISEED)
END DO

RETURN
END
**==rcarry.spg processed by SPAG 4.52O at 11:03 on 18 Oct 1996


FUNCTION RCARRY()
C----------------------------------------------------------------------C
C Random number generator from Marsaglia.
C----------------------------------------------------------------------C
IMPLICIT NONE
REAL*8 CARRY, RCARRY, SEED, TWOm24, TWOp24, uni
INTEGER I24, ISEED, J24
PARAMETER (TWOp24=16777216.D+0, TWOm24=1.D+0/TWOp24)
COMMON /RANDOM/ SEED(24), CARRY, I24, J24, ISEED
c
c f.james Comp. Phys. Comm. 60, 329 (1990)
c algorithm by G. Marsaglia and A. Zaman
c base b = 2**24 lags r=24 and s=10
c
uni = SEED(I24) - SEED(J24) - CARRY
IF (uni.LT.0.D+0) THEN
uni = uni + 1.D+0
  ; CARRY = TWOm24
ELSE
CARRY = 0.D+0
END IF
SEED(I24) = uni
I24 = I24 - 1
IF (I24.EQ.0) I24 = 24
J24 = J24 - 1
IF (J24.EQ.0) J24 = 24
RCARRY = uni

RETURN
END

[Steven_L_Intel1]

I spotted one problem - function RANF returns DOUBLE PRECISION but you did not declare RANF as DOUBLE PRECISION in the calling routine. This will cause exactly the kind of problem you saw.

I suggest also adding the switches:

-gen-interface -warn interface

to your ifort line and you may see other errors (I did not test this.)

[fassisalmeida]

Your suggestion solved my problem.
Thanks!