CODEWITHSUNDEEP
fortran
bcf
bcf

Reputation: 2134

Defining a variable that must be declared constant, but changes in a loop

I'm testing out ranges of values (-1:34 just for kicks) for the function selected_real_kind to determine the kind parameter it returns and the actual number of bits of precision used by a variable defined using this kind. I'm stuck with how to define variable RP below, though, since the function to convert the variables x, u and alpha (real(x,RP) e.g.) require that RP (the kind type) to be constant.

If I define RP to be a parameter, i.e. at the top write integer, parameter :: RP I have to initialize it immediately, and then I obviously can't change it because, well, it's a parameter, so this won't work.

Here's what I have:

program f1
  implicit none
  integer :: n,t  ! n used in selected_real_kind(n), t is precision (#bits)
  integer :: RP
  real :: x=1.5, u=1.0, alpha=1.0  ! will be reset using _RP below                                                                               

  print '(A2,A4,A4)', "n", "RP", "t"  ! header for values

  do n=-1,34
     RP = selected_real_kind(n)

     ! convert x,u,alpha to type RP.  These functions throw the error!                               
     x = real(x,RP)
     u = real(u,RP)
     alpha = real(alpha,RP)

     ! init precision test variables                                                                                                             
     x=1.5_RP
     u=1.0_RP
     alpha=1.0_RP

     ! reset precision value to zero before each test                                                                                            
     t = 0

     ! precision test                                                                                                                            
     do while(x>alpha)
        u = u/2.0_RP
        x = alpha+u
        t = t+1
     end do

     print '(I2 I4 I4)', n, RP, t
  end do

end program f1

Upvotes: 2

Views: 574

Answers (3)

agentp
agentp

Reputation: 6989

elaborating on my comment, here is a python example:

 fortrancode = """
       implicit none
       integer, parameter :: n=%i
       integer,parameter :: rp=selected_real_kind(n)      
       write(*,*)n,rp
       end
 """
 from subprocess import call
 for n in range(-1,33):
  f=open('test.f','w')
  f.write(fortrancode%(n))  ! <- n here gets string substituted
                            !for the '%i' in fortrancode
  f.close()
   ! optional check  call(['grep','n=','test.f'])
  call(['gfortran','test.f','-o','test.exe'])
  call(['./test.exe'])

python test.py

 -1 4
  0 4
  1 4
...
  7 8
...
 18 10
 19 -1
...
 32 -1

Upvotes: 1

francescalus
francescalus

Reputation: 32366

Similar to george's answer, but in Fortran. We note that kinds are something that, essentially, must be known at compile-time. For that we ask the compiler which kinds it can offer us and, for each of those, create a small chunk of code to be compiled. Then compile and run it. [This last step certainly varies by system.]

! Rather than looping over a range with SELECTED_REAL_KIND, just see which
! real kinds are available to the compiler.  We can later match up real kinds
! for a requested precision with those here.
  use, intrinsic :: iso_fortran_env, only : real_kinds
  implicit none

  integer output
  integer i

  open(newunit=output, file='gosh.f90', action='write', position='rewind')

! Here we could instead do n=-1, 34 etc.
  do i=1, SIZE(real_kinds)
     write(output, 1) real_kinds(i)
  end do

  write(output, '("end")')
  close(output)

! A compile/execute line - do whatever is required.
  call execute_command_line('compile gosh.f90 && ./a.out')

1 FORMAT ("block",/,"real(",I0,") x",/,"include 'domystuffz'"/,"end block")

end

where "domystuffz" is a file containing whatever analysis is wanted. As with High Performance Mark's answer something intrinsic would be nice and the include could be replaced by some simple code if required.

Upvotes: 1

High Performance Mark
High Performance Mark

Reputation: 78324

Fortran provides a number of intrinsic functions for enquiring into the characteristics of the numbers it processes. Consult your documentation for functions such as digits, precision and radix. All of these (including the ones I haven't mentioned but which your documentation will list) are generic (enough) to work on inputs of all the numeric kinds supported by your compiler.

You'll make headway faster using these functions than trying to roll your own. As you are discovering it's not a simple matter to write your own generic routines as Fortran wants kind selectors known (or knowable) at compile time. You'll also extend your knowledge of Fortran.

You may also find functions of interest in the intrinsic module IEEE_ARITHMETIC.

Upvotes: 1

Related Questions