Fortran
I / O

Sintaxis

• WRITE(unit num, format num) genera los datos después de los corchetes en una nueva línea.
• READ(unit num, format num) entradas a la variable después de los corchetes.
• OPEN(unit num, FILE=file) abre un archivo. (Hay más opciones para abrir archivos, pero no son importantes para E / S.
• CLOSE(unit num) cierra un archivo.

E / S simple

Como ejemplo de escritura de entrada y salida, tomaremos un valor real y devolveremos el valor y su cuadrado hasta que el usuario ingrese un número negativo.

Como se especifica a continuación, el comando de read toma dos argumentos: el número de unidad y el especificador de formato. En el siguiente ejemplo, usamos * para el número de unidad (que indica stdin) y * para el formato (que indica el valor predeterminado para reales, en este caso). También especificamos el formato para la declaración de print . Alternativamente, se puede usar write(*,"The value....") o simplemente ignorar el formato y tenerlo como

print *,"The entered value was ", x," and its square is ",x*x

lo que probablemente resultará en algunas cadenas y valores espaciados de manera extraña.

program SimpleIO
   implicit none
   integer, parameter :: wp = selected_real_kind(15,307)
   real(kind=wp) :: x
   
   ! we'll loop over until user enters a negative number
   print '("Enter a number >= 0 to see its square. Enter a number < 0 to exit.")'
   do
      ! this reads the input as a double-pricision value
      read(*,*) x
      if (x < 0d0) exit
      ! print the entered value and it's square
      print '("The entered value was ",f12.6,", its square is ",f12.6,".")',x,x*x
   end do
   print '("Thank you!")'
   
end program SimpleIO

Leer con un poco de comprobación de errores

Un ejemplo moderno de Fortran que incluye la verificación de errores y una función para obtener un nuevo número de unidad para el archivo.

module functions

contains

    function get_new_fileunit() result (f)
        implicit none

        logical    :: op
        integer    :: f

        f = 1
        do 
            inquire(f,opened=op)
            if (op .eqv. .false.) exit
            f = f + 1
        enddo

    end function

end module

program file_read
    use functions, only : get_new_fileunit
    implicit none

    integer            :: unitno, ierr, readerr
    logical            :: exists
    real(kind(0.d0))   :: somevalue
    character(len=128) :: filename

    filename = "somefile.txt"

    inquire(file=trim(filename), exist=exists)
    if (exists) then
        unitno = get_new_fileunit()
        open(unitno, file=trim(filename), action="read", iostat=ierr)
        if (ierr .eq. 0) then
            read(unitno, *, iostat=readerr) somevalue
            if (readerr .eq. 0) then
                print*, "Value in file ", trim(filename), " is ", somevalue
            else
                print*, "Error ", readerr, & 
                        " attempting to read file ", & 
                        trim(filename)
            endif
        else
            print*, "Error ", ierr ," attempting to open file ", trim(filename)
            stop
        endif
    else
        print*, "Error -- cannot find file: ", trim(filename)
        stop
    endif

end program file_read

Pasando argumentos de línea de comando

Donde se admiten los argumentos de la línea de comando, se pueden leer a través del intrínseco get_command_argument (introducido en el estándar Fortran 2003). El intrínseco command_argument_count proporciona una manera de conocer el número de argumentos proporcionados en la línea de comandos.

Todos los argumentos de la línea de comando se leen como cadenas, por lo que se debe realizar una conversión de tipo interna para los datos numéricos. Como ejemplo, este código simple suma los dos números proporcionados en la línea de comando:

PROGRAM cmdlnsum
IMPLICIT NONE
CHARACTER(100) :: num1char
CHARACTER(100) :: num2char
REAL :: num1
REAL :: num2
REAL :: numsum

!First, make sure the right number of inputs have been provided
IF(COMMAND_ARGUMENT_COUNT().NE.2)THEN
  WRITE(*,*)'ERROR, TWO COMMAND-LINE ARGUMENTS REQUIRED, STOPPING'
  STOP
ENDIF

CALL GET_COMMAND_ARGUMENT(1,num1char)   !first, read in the two values
CALL GET_COMMAND_ARGUMENT(2,num2char)

READ(num1char,*)num1                    !then, convert them to REALs
READ(num2char,*)num2

numsum=num1+num2                        !sum numbers
WRITE(*,*)numsum                        !write out value

END PROGRAM

El argumento del número en get_command_argument útilmente entre 0 y el resultado de command_argument_count . Si el valor es 0 se proporciona el nombre del comando (si se admite).

Muchos compiladores también ofrecen intrínsecos no estándar (como getarg ) para acceder a los argumentos de la línea de comandos. Como estos no son estándar, se debe consultar la documentación del compilador correspondiente.

El uso de get_command_argument puede extenderse más allá del ejemplo anterior con los argumentos de length y status . Por ejemplo, con

character(5) arg
integer stat
call get_command_argument(number=1, value=arg, status=stat)

el valor de stat será -1 si el primer argumento existe y tiene una longitud mayor que 5. Si hay alguna otra dificultad para recuperar el argumento, el valor de stat será un número positivo (y arg constará completamente de espacios en blanco). De lo contrario su valor será 0 .

El argumento de length se puede combinar con una variable de carácter de longitud diferida, como en el siguiente ejemplo.

character(:), allocatable :: arg
integer arglen, stat
call get_command_argument(number=1, length=arglen)  ! Assume for simplicity success
allocate (character(arglen) :: arg)
call get_command_argument(number=1, value=arg, status=stat)