Call the same subroutine/function with different precision

  • Thread starter MariosB
  • Start date
  • #1
4
0
Hello everyone,

As a part of my computational physics course i have been assigned a homework which is pretty simple. My problem is in optimising my source code. So the task is this:

Write programs that calculate the machine round-off error for a real type variable with precision levels : kind=4, kind=8, kind=10. If we think this in terms of making different source codes or even a main program that will call three separate subroutines each one setting our desired amount of precision it would be easy and the code is something along the lines of this
Code:
      PROGRAM Machine Epsilon
      implicit none
      
      integer :: exit,choice,counter
      common /counts/counter   ! if i declared this inside the subprogram each time it would run anew it
      						   ! would not reset the counter value. Outside seems to work just fine.
      
						   
      Print*,						   
      Print*,' This program calculates the machine Round-off error,epsilon, for single, '
      Print*,' double and high precision. Please specify the desired level of precision.'
	  Write(*,*)
	         
       
 5    Print*,' For single precision press 1 '
      Print*,' For double precision press 2 '
      Print*,' For high   precision press 3 '
      Print*,
      Print*,' To exit press 5'
       
      Read*, choice
       
      do while ((choice.ne.1).and.(choice.ne.2).and.(choice.ne.3).and.(choice.ne.5))      
      	Print*,' Invalid choice '
       	Print*,' Please select the amount of precision you prefer '
       	Print*,' for the calculation '
        Print*,' For single precision press 1 '
        Print*,' For double precision press 2 '
        Print*,' For high   precision press 3 '
        Read(*,*) choice
	  end do

       
      select case (choice)
      	case(1)
      	counter=0
      	call precision_4
      	case(2)
      	counter=0
      	call precision_8
      	case(3)
      	counter=0
      	call precision_10
      	case(5)
      	go to 60
      end select
                     
 48   Print*,'Press 5 to exit or 4 to start again'
      Read(*,*) exit
       
      if ( exit .EQ. 5 ) then
       go to 60 
      elseif ( exit .EQ. 4) then
       go to 5	 
      else 
       go to 48
      end if  
        
              
 60   end program machine epsilon
  
c Single Precision Subroutine  
c=======================================================================================================

      subroutine precision_4
       
      real(kind=4) :: temp,epsilon
      integer :: counter
      common /counts/counter
       
      temp=1.5 ! the value of variable temp has been selected at random, with the sole limitation 
               ! it being reasonably higher to the machine roundoff error for the following calculation
               ! to have meaning.

      do while ( temp+1.0 .gt. 1.0 )
               
      	temp=temp/2.
       	epsilon=temp
       	counter=counter+1
        	        	
      end do
       
      Print*,' Machine round-off error is, e = ',epsilon
      Print*,' Calculated after ',counter,' repetitions'
       
      return
      end subroutine precision_4

c Double Precision subroutine
c=======================================================================================================       

      subroutine precision_8
       
      real(kind=8) :: temp,epsilon
      integer counter
      common /counts/counter

      
      temp=0.5 
                
      do while ( temp+1.0 .gt. 1.0 )
               
      	temp=temp/2.
       	epsilon=temp
       	counter=counter+1
        	        	
      end do
       
      Print*,' Machine round-off error is, e = ',epsilon
      Print*,' Calculated after ',counter,' repetitions'
            
      return
      end subroutine precision_8  

c High Precision Subroutine       
c=======================================================================================================

      subroutine precision_10
       
      real(kind=10) :: temp,epsilon
      integer :: counter
      common /counts/counter
      
      temp=1.5 ! the value of variable temp has been selected at random, with the sole limitation 
               ! it being reasonably higher to the machine roundoff error for the following calculation
               ! to have meaning.
                
      do while ( temp+1.0 .gt. 1.0 )
               
      	temp=temp/2.
       	epsilon=temp
       	counter=counter+1
        	        	
      end do
       
      Print*,' Machine round-off error is, e = ',epsilon
      Print*,' Calculated after ',counter,' repetitions'
      
      return
      end subroutine precision_10            
       
c=======================================================================================================

As i said, i want to optimise my program, in this sense :

I want to have only one kind of subroutine that will be calculating each time the round-off error but i want to be able to change the kind of the real type variables accordingly depending of the level of precision i want. For this reason i have tried to write something like this :

Code:
      module PrecisionLevel
      
      integer, parameter :: kd4=4,kd8=8,kd10=10
      
      external epsilon
      
      end module PrecisionLevel

      PROGRAM Machine roundoff error
      implicit none
      
      integer :: ext,choice
      
						   
      Print*,						   
      Print*,' This program calculates the machine Round-off error,epsilon, for single, '
      Print*,' double and high precision. Please specify the desired level of precision.'
	  Write(*,*)
	         
       
 5    Print*,' For single precision press 1 '
      Print*,' For double precision press 2 '
      Print*,' For high   precision press 3 '
      Print*,
      Print*,' To exit press 5'
       
      Read*, choice
       
      do while ((choice.ne.1).and.(choice.ne.2).and.(choice.ne.3).and.(choice.ne.5))      
      	Print*,' Invalid choice '
       	Print*,' Please select the amount of precision you prefer '
       	Print*,' for the calculation '
        Print*,' For single precision press 1 '
        Print*,' For double precision press 2 '
        Print*,' For high   precision press 3 '
        Read(*,*) choice
	  end do

       
      select case (choice)
      	case(1)
      	call precision_calc(choice)
      	case(2)
      	call precision_calc(choice)
      	case(3)
      	call precision_calc(choice)
      	case(5)
      	go to 60
      end select
                     
 48   Print*,'Press 5 to exit or 4 to start again'
      Read(*,*) ext
       
      if ( ext .EQ. 5 ) then
       goto 60 
      else if ( ext .EQ. 4) then
       goto 5	 
      else 
       goto 48
      end if  
        
              
 60   end program machine roundoff error
  
! Single Precision Subroutine  
!=======================================================================================================

      subroutine precision_calc(choice)
      integer :: counter,choice
      
      select case (choice)
      	case(1)
      	use PrecisionLevel, only: kd4=>kd
      	case(2)
      	use PrecisionLevel, only: kd8=>kd
      	case(3)
      	use PrecisionLevel, only:kd10=>kd
      end select
      real(kind=kd) :: temp,U
             
      temp=0.5 
	  counter=0
      do while ( temp+1._kd .gt. 1._kd )
               
      	temp=temp/2._kd
       	U=temp
       	counter=counter+1
        	        	
      end do
       
      Print*,' Machine round-off error is, e = ',U
      Print*,' Calculated after ',counter,' repetitions'
       
      return
      end subroutine precision_calc
The idea is to incert a module which will set the kind in an integer-parameter and it will be used later on depending on the selection of the user. Since it is the first time i have ever needed to write something like that could you please tell me if the syntax i am using is even possible ? My idea is that each time the subroutine precison_calc(choice) will be called a different type of use command will be activated depending on the original choice of the user. But can i use the "use" statement in such a way either inside or outside the subroutine?

Also, does any1 know how can i see Fortran 77 / 90/95 intrinsic functions source codes? I have a hunch that be studying the structure of the mathematical intrinsic functions I can probably find a solution to my problem.

My interest is mainly academic in nature.

Thanks in advance !
 

Answers and Replies

Related Threads on Call the same subroutine/function with different precision

Replies
4
Views
9K
Replies
2
Views
2K
Replies
3
Views
677
  • Last Post
Replies
0
Views
1K
Replies
2
Views
658
Replies
2
Views
986
Replies
8
Views
2K
Replies
0
Views
2K
Replies
6
Views
2K
Replies
4
Views
3K
Top