Fortran
IO

Syntaxis

• WRITE(unit num, format num) voert de gegevens achter de haakjes uit op een nieuwe regel.
• READ(unit num, format num) voert de invoer in naar de variabele achter de haakjes.
• OPEN(unit num, FILE=file) opent een bestand. (Er zijn meer opties voor het openen van bestanden, maar deze zijn niet belangrijk voor I / O.
• CLOSE(unit num) sluit een bestand.

Eenvoudige I / O

Als een voorbeeld van het schrijven van invoer en uitvoer, nemen we een echte waarde en geven we de waarde en het kwadraat terug totdat de gebruiker een negatief getal invoert.

Zoals hieronder gespecificeerd, heeft de opdracht read twee argumenten: het eenheidsnummer en de opmaakspecificatie. In het onderstaande voorbeeld gebruiken we * voor het eenheidsnummer (dat stdin aangeeft) en * voor het formaat (dat in dit geval de standaardwaarde voor reals aangeeft). We specificeren ook het formaat voor de print . Je kunt ook write(*,"The value....") of gewoon de opmaak negeren en het als hebben

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

wat waarschijnlijk resulteert in een aantal vreemd gespreide tekenreeksen en waarden.

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

Lezen met enige foutcontrole

Een modern Fortran-voorbeeld met foutcontrole en een functie om een nieuw eenheidsnummer voor het bestand te krijgen.

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

Opdrachtregelargumenten doorgeven

Waar opdrachtregelargumenten worden ondersteund, kunnen deze worden ingelezen via het intrinsic get_command_argument (geïntroduceerd in de Fortran 2003-standaard). De command_argument_count intrinsieke biedt een manier om het aantal argumenten op de opdrachtregel te leren kennen.

Alle opdrachtregelargumenten worden ingelezen als tekenreeksen, dus moet een interne typeconversie worden uitgevoerd voor numerieke gegevens. Deze eenvoudige code somt bijvoorbeeld de twee nummers op de opdrachtregel op:

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

Het argument voor get_command_argument in get_command_argument varieert handig tussen 0 en het resultaat van command_argument_count . Als de waarde 0 wordt de opdrachtnaam opgegeven (indien ondersteund).

Veel compilers bieden ook niet-standaard intrinsiek (zoals getarg ) voor toegang tot opdrachtregelargumenten. Aangezien deze niet-standaard zijn, moet de bijbehorende compiler-documentatie worden geraadpleegd.

Gebruik van get_command_argument kan worden verlengd bovenstaand voorbeeld de length en status argumenten. Bijvoorbeeld met

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

de waarde van stat is -1 als het eerste argument bestaat en een lengte heeft die groter is dan 5. Als er een andere moeilijkheid is om het argument te achterhalen, zal de waarde van stat een positief getal zijn (en arg zal volledig uit spaties bestaan). Anders is de waarde 0 .

Het argument length kan worden gecombineerd met een variabele met een uitgestelde lengte, zoals in het volgende voorbeeld.

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)