I'm not aware of such a function in GNU Fortran. The standards-compliant method is to check the value of IOSTAT after each read. There is a helper function as of Fortran 2003 called IS_IOSTAT_END that should make things easier. Have a look at https://gcc.gnu.org/onlinedocs/gfortran … 5fEND.html to see a short example.
]]>Don
]]>I checked the program and it does use EXP. So I added Dr. Frank's FXP. I get the same results with either function. So, EXP doesn't seem to be causing any problem. But thanks to all for you suggestions.
Don
]]>If you're using an exponential function, you might want to consider an alternative algorithm like the one below:
The exponential in the runtime library tends to be problematic for some reason. I'll have to look into it far deeper.
]]>Now if we had the little window into the debugger, we could inspect such arrays using gdb's print command.
p x(1)
p x(10) ... etc
Actually, if the array is allocatable, the above will not work in current versions of the GNU Debugger. Simply Fortran is effectively doing the above (but not exactly, of course), and it will not work. The GNU Debugger does not currently understand allocatable arrays in Fortran.
Do you know if this is just a limitation in the current version for arrays only with the allocatable attribute or does it apply to deferred arrays generally (e.g. with the pointer attribute)?
I believe the shortcoming extends to pointers that are allocated. If they point at a statically declared target, they should work.
All of this trouble should be gone this week, though, when 2.19 is released.
]]> ! ------------------------------------------------------------------
Function FXP(x)
!--- Fxponential function
!--- Fast Exponential FXP() - F.W. Perrella, Ph.D. (2014)
IMPLICIT NONE
REAL(dp), INTENT(IN) :: x
REAL(dp) :: x0,x1,x2,x3,x4,FXP
REAL(dp), PARAMETER :: xa = 0.5, xb = 65535., xc = 256., xd = 1.
x1 = (xb + x)/xb
x2 = x1**xc
x3 = x2**xc
x4 = xd + (xa*x*x/xb)*(xd + (xa*x + xa*xa*x*x - x)/xb)
FXP = x3*x4
End Function FXP
! ------------------------------------------------------------------
Although it's not quite as accurate as the intrinsic function EXP(), FXP() is stable and may be accurate enough for your application.
Frank
]]>p x(1)
p x(10) ... etc
Do you know if this is just a limitation in the current version for arrays only with the allocatable attribute or does it apply to deferred arrays generally (e.g. with the pointer attribute)?
]]>I'm currently testing a version of the debugger that does support viewing allocated array elements. I'm only concerned about stability at this point as the entire code base of the debugger that supports this is a development version (as opposed to the "stable" releases we ship). It wouldn't help if the debugger just randomly crashed constantly. I will keep everyone updated, though. This missing feature is frustrating to all our users.
]]>That explains the issue you're seeing. The debugger currently does not support examining the contents of allocated elements. We're using the GNU Debugger within Simply Fortran, and it does not yet support Fortran allocated arrays. I would expect support to be present in a few more months. Patches have been submitted, but not accepted yet.
This lack of support has been a long outstanding issue. I understand the frustration of users, and we're working to possibly incorporate patches into our distribution of the GNU Debugger.
]]>