Introduzione alla Programmazione Strutturata in Fortran 90 by hcw25539

VIEWS: 25 PAGES: 55

									          a
 Universit` degli Studi di Napoli Federico II


         Corso di Dinamica del Volo
Introduzione alla Programmazione Strutturata
                 in Fortran 90



               Agostino De Marco

                 a
        Universit` degli Studi di Napoli
        Dipartimento di Progettazione Aeronautica
        Via Claudio, 21 – 80125 Napoli
        Email: agodemar@unina.it
     e
Perch´ Programmazione Strutturata ?



Risoluzione di problemi scientifici
   • trattamento dati
   • simulazioni


Utilizzo dei computers
   • grandi capacit` di memoria
                   a
   • alta velocit` di esecuzione
                 a
Rappresentazione dei dati in un computer

Memoria
   • milioni di switches on/off, 1/0
     binary digits, bits


   • gruppi di bits, sistema binario di rappresentazione


   • byte, gruppo di 8 bits consecutivi


   • parola macchina, word: 2, 4 o 8 bytes contigui per la
     rappresentazione dei numeri in virgola mobile,
     dipende dal tipo di computer!
Rappresentazione dei dati: un po’ di numeri


Memoria:     insieme di   bits,   raggruppati in   bytes

   • N bits ⇒ 2N possibili combinazioni (valori)


   • 8 bits ⇒ 28 = 256 (1 byte)


   • 16 bits ⇒ 216 = 65, 536 (2 byte)


   • 32 bits ⇒ 232 = 4, 294, 967, 296 (4 byte)
Tipi di dati


Tipo Carattere
   • ASCII, 1 byte
     American Standard Code Information Interchange


   • ASCII extended, ISO–646, 1 byte


   • EBCDIC, 1 byte
     Extended Binary Coded Decimal Interchange Code


   • Unicode, 2 bytes (set di circa 65000 caratteri)
Tipi di dati (II)


Tipo Intero
    • interi positivi, lo zero, interi negativi


    • 1, 2, 4 o 8 bytes


    • range −2N −1 ≤ . . . ≤ 2N −1 − 1


    • 4 bytes ⇒ N = 32 ⇒ −2 × 109 ≤ . . . ≤ 2 × 109
Tipi di dati (III)


Tipo Reale
    • numeri in virgola mobile o floating point


    • notazione scientifica, in base 2:


      numero = mantissa × 2esponente
      −1 ≤ mantissa ≤ +1


    • 4, 8 o 16 bytes
Tipi di dati (IV)

Tipo Reale,         numero = mantissa × 2esponente
   • precision, p
     p = N. di bits in mantissa ⇒ N. di cifre significative


   • range, r
     r = N. di bits in esponente ⇒ Max. − min.


   • rappresentazione con 4 bytes (single precision)
     24 bits in mantissa, 8 bits in esponente
     24 bits ⇒ 223 combinazioni ⇒ 7 cifre significative
     8 bits ⇒ 2−128 ≤ . . . ≤ 2128 ⇒ 10−38 ≤ . . . ≤ 1038
Tipi di dati (V)


Tipo Reale,      numero = mantissa × 2esponente


   • N. limitato di cifre signif. ⇒ errori di round–off


   • double precision: rappresentazione con 8 bytes
     PC Pentium
     precision: 17 cifre significative
     range: 10−307 ≤ . . . ≤ 10307
Linguaggi di programmazione

linguaggi ‘di basso livello’
    • operazioni semplici: load, store, add, subtract, multiply
    • ‘operation code’, ‘op code’ e operands
    • programma in linguaggio macchina: stringa di op codes


linguaggi ‘di alto livello’
    • vicini al linguaggio umano, English–like statements
    • statements tradotti in linguaggio macchina dal compilatore/linker
    • caratteristiche di un linguaggio → categoria di problemi
       gestione database, sistemi operativi, interfacce grafiche, ...
    • linguaggio Fortran → problemi scientifici
       50 anni di storia, supercomputers, massively parallel computers
Linguaggi di programmazione (II)

processo di build di un programma:
    • sorgenti: contengono gli statements Fortran, in formato testo
    • compilazione −→ ‘object files’
    • link con librerie di sistema, matematiche, grafiche, I/O
       −→ ‘executable file’


gestione delle fasi di build:
    • i dettagli della compilazione e del linker
       dipendono dal sistema operativo
    • Integrated Development Environment, IDE
    • Windows 9X/NT/2000: Microsoft Developer Studio,
       Compaq Visual Fortran
Program Design

Statements di controllo
   • Branches
   • Loops

Top–Down Design
   • programmazione ‘procedurale’
   • abolita la programmazione ‘on the fly’
   • studio attento delle procedure necessarie
   • uso di diagrammi di flusso, pseudocodici
   • capire il problema da risolvere
     ⇒ break-down in subtasks
   • test e correzioni indipendenti dei subtasks
Il processo Top–Down

1. formulazione chiara del problema da risolvere
    esempio: Scrivere un programma che risolve un sistema di equazioni
      lineari, a coefficienti reali, con un massimo di 20 incognite.

2. definizione di input e output

3. progettazione dell’algoritmo che si intende implementare
    step–by–step; decomposition; subtask refinement
    utilizzo di pseudolinguaggio → costrutti: ‘algoritmo strutturato’

4. ‘codifica’ in linguaggio Fortran

5. test del programma
    funzionamento corretto per un insieme completo di input leciti
    verifica di ciascun branch del codice
Gestione di grandi progetti software

1. Unit Testing → verifica di ciascun subtask

2. Successive Builds → combinazione progressiva dei subtasks;
  check delle interazioni tra i diversi subtasks

3. Alpha–Release → prima versione del programma completo
  bug–fixing dei programmatori

4. Beta–Release → eliminati i bug pi` importanti
                                    u
  bug–fixing dei ‘friendly outside users’; bug–reporting

5. Release 1.0
    rilascio per un uso generale del programma
    customer support
Panoramica sul Fortran 90

Evoluzione del linguaggio FORTRAN:
  FORmula TRANslation

   • primo compilatore: 1957
   • primo standard ufficiale: 1972, ‘Fortran 66’
   • prima revisione nel 1980: ‘Fortran 77’
   • successiva revisione nel 1991: ‘Fortran 90’
   • ultima revisione: 1996, ‘Fortran 95’
   • lo ‘standard Fortran 90/95’ ` oggi certificato
                                 e
     ISO/IEC ed ANSI
Panoramica sul Fortran 90

Evoluzione del linguaggio FORTRAN:
  FORmula TRANslation

   • primo compilatore: 1957
   • primo standard ufficiale: 1972, ‘Fortran 66’
   • prima revisione nel 1980: ‘Fortran 77’
   • successiva revisione nel 1991: ‘Fortran 90’
   • ultima revisione: 1996, ‘Fortran 95’
   • lo ‘standard Fortran 90/95’ ` oggi certificato
                                 e
     ISO/IEC ed ANSI
Panoramica sul Fortran 90

Evoluzione del linguaggio FORTRAN:
  FORmula TRANslation

   • primo compilatore: 1957
   • primo standard ufficiale: 1972, ‘Fortran 66’
   • prima revisione nel 1980: ‘Fortran 77’
   • successiva revisione nel 1991: ‘Fortran 90’
   • ultima revisione: 1996, ‘Fortran 95’
   • lo ‘standard Fortran 90/95’ ` oggi certificato
                                 e
     ISO/IEC ed ANSI
Panoramica sul Fortran 90

Evoluzione del linguaggio FORTRAN:
  FORmula TRANslation

   • primo compilatore: 1957
   • primo standard ufficiale: 1972, ‘Fortran 66’
   • prima revisione nel 1980: ‘Fortran 77’
   • successiva revisione nel 1991: ‘Fortran 90’
   • ultima revisione: 1996, ‘Fortran 95’
   • lo ‘standard Fortran 90/95’ ` oggi certificato
                                 e
     ISO/IEC ed ANSI
Panoramica sul Fortran 90

Evoluzione del linguaggio FORTRAN:
  FORmula TRANslation

   • primo compilatore: 1957
   • primo standard ufficiale: 1972, ‘Fortran 66’
   • prima revisione nel 1980: ‘Fortran 77’
   • successiva revisione nel 1991: ‘Fortran 90’
   • ultima revisione: 1996, ‘Fortran 95’
   • lo ‘standard Fortran 90/95’ ` oggi certificato
                                 e
     ISO/IEC ed ANSI
Panoramica sul Fortran 90

Evoluzione del linguaggio FORTRAN:
  FORmula TRANslation

   • primo compilatore: 1957
   • primo standard ufficiale: 1972, ‘Fortran 66’
   • prima revisione nel 1980: ‘Fortran 77’
   • successiva revisione nel 1991: ‘Fortran 90’
   • ultima revisione: 1996, ‘Fortran 95’
   • lo ‘standard Fortran 90/95’ ` oggi certificato
                                 e
     ISO/IEC ed ANSI
Scopi dello standard Fortran 90/95


Un compromesso tra i seguenti criteri:


    • Fortran 77 come subset, backward compatibility
    • efficienza
    • portabilit`
                a
    • regolarit`
               a
    • semplicit` d’uso
               a
Svantaggi del Fortran 77

il Fortran 77 aveva i seguenti limiti:


    • sorgenti in formato ‘fixed form’
    • allocazione dinamica non implementata
    • difficile portabilit`
                        a
    • tipo di dati definiti da utente non implementato
    • ricorsione esplicita non implementata
    • gestione inaffidabile dei dati conservati in memoria
Nuove caratteristiche del Fortran 90

il Fortran 90 supporta:
    • sorgenti in formato libero, ‘free source form’
    • operazioni e manipolazione di interi arrays, array sintax
    • allocazione dinamica e uso di puntatori
    • portabilit` dei tipi di dati (KIND)
                a
    • tipi di dati ed operatori derivati, definiti da utente
    • ricorsione
    • utilizzo dei MODULE
    • procedure interfaces
    • generic procedures definite dall’utente
    • costrutti di controllo migliorati
    • operazioni di I/O migliorate
Formato dei sorgenti


    Free source form:


        • 132 caratteri per linea
        • ‘!’ carattere che inizia una linea di commento
        • ‘&’ carattere di continuazione linea
        • ‘;’ separatore tra due diversi statements
        • spazi bianchi dotati di significato


Esempio:

1    PRINT*, ’’This line is continued &
2    &On the next line’’; END ! of program
Dichiarazioni ed Attributi


 • dichiarazione IMPLICIT NONE
   obbliga alla dichiarazione delle variabili


 • sintassi delle dichiarazioni:


      <type> [, <attributelist> ] [::]&
      <variablelist> [ = <value> ]
Esempio

Le seguenti sono tutte dichiarazioni valide:


1    SUBROUTINE Sub(x,i,j)
2    !----------------------------------- Sezione Dichiarativa
3    IMPLICIT NONE
4    REAL, INTENT(IN) :: x
5    LOGICAL, POINTER :: ptr
6    REAL z(10)
7    REAL, DIMENSION(10,10) :: y
8    CHARACTER(LEN=*), PARAMETER :: str = ’Maud’’dib’
9    INTEGER, TARGET :: k = 4
10   ...
11   !-------------------------------------- Sezione Esecutiva
12   ...



l’attributo DIMENSION dichiara un array 10 × 10
z(10) dimensiona z come array monodimensionale
Nuovi costrutti di controllo

maggiore chiarezza del costrutto IF,
labels alfanumeriche e nuovi operatori logici:


1    zob: IF (A > 0) THEN
2       ...
3    ELSEIF (A == -1) THEN zob
4       ...
5    ELSE zob
6       chum: IF (c == 0 .EQV. B >= 0) THEN
7          ...
8       ENDIF chum
9       ...
10   ENDIF zob
Nuovi costrutti di controllo (II)

costrutto SELECT CASE per espressioni intere e di tipo carattere:


1    SELECT CASE (case_expr)
2    CASE (1,3,5)
3       ...
4    CASE (2,4,6)
5       ...
6    CASE (7:10)
7       ...
8    CASE (11:)
9       ...
10   CASE DEFAULT
11      ...
12   END SELECT
Nuovi costrutti di controllo (III)

maggiore chiarezza del costrutto DO,
labels alfanumeriche anche per i loops, nuovi statement CYCLE ed EXIT:


1    outer_loop: DO i = 1, n
2       inner_loop: DO j = 1, m
3          ...
4          IF ( X == 0   ) EXIT        ! logical IFs
5          ...
6          IF ( X < 0    ) EXIT        outer_loop
 7         ...
 8         IF ( X > 10 ) CYCLE         inner_loop
 9         ...
10         IF ( X > 100 ) CYCLE        outer_loop
11         ...
12      END DO inner_loop
13   END DO outer_loop
Nuovi costrutti di controllo (IV)

costrutto DO e DO WHILE:


1    CHARACTER*132 :: string
2    INTEGER :: i
3    ...
4    i = 0
5    leading_blanks: DO
6        i = i + 1
7        IF ( string(i:i) .NE. ’ ’ ) EXIT leading_blanks
8        WRITE (*, *) i
9        ...
10   END DO leading_blanks


 1   CHARACTER(1) :: input
 2   ...
 3   input = ’ ’
 4   DO WHILE ((input .NE. ’n’) .AND. (input .NE. ’y’))
 5       WRITE (*, ’(A)’) ’Enter y or n: ’
 6       READ (*, ’(A)’) input
 7   END DO
Nuove caratteristiche delle procedure

‘internal procedures’:
1    SUBROUTINE Subby(a,b,c)
2    IMPLICIT NONE
3    ...
4    CALL Inty(a,c)
5    ...
6    CONTAINS
7        SUBROUTINE Inty(x,y)
8        ...
9        END SUBROUTINE Inty
10   ...
11   END SUBROUTINE Subby


l’attributo INTENT:
1    SUBROUTINE MySub(a,b,rc)
2    IMPLICIT NONE ! New too
3    REAL, INTENT(IN) :: a
4    REAL, INTENT(INOUT) :: b
5    INTEGER, INTENT(OUT) :: rc
6     ...
7    END SUBROUTINE MySub ! New END
Nuove caratteristiche delle procedure (II)

argomenti di scambio opzionali e di tipo keyword:
1    MODULE MioModulo
2
3    CONTAINS
4       SUBROUTINE MiaSubroutine(scale,x,y)
5       IMPLICIT NONE ! Use it
6       REAL, INTENT(IN) :: x,y ! New format
7       REAL, INTENT(IN), OPTIONAL :: scale
8       REAL :: actual_scale
9
10      actual_scale = 1.0
11      IF (PRESENT(scale)) actual_scale = scale
12      CALL Plot_line(x,y,actual_scale)
13      END SUBROUTINE MiaSubroutine ! piu’ elegante
14   MODULE MioModulo


esempi di chiamata:
USE MioModulo
 ...
CALL MiaSubroutine( y=2.0, x=1.0 )   ! N.B.
CALL MiaSubroutine( 10.0, 1.0, 2.0 ) ! ordine naturale
Nuove caratteristiche delle procedure (III)

e
` permessa la ricorsione esplicita:


 1   RECURSIVE SUBROUTINE Factorial(N, Result)
 2
 3   IMPLICIT NONE
 4   INTEGER, INTENT(IN) :: N
 5   INTEGER, INTENT(INOUT) :: Result
 6
 7   IF (N > 0) THEN
 8      CALL Factorial(N-1,Result) ! chiama se stessa
 9      Result = Result * N
10   ELSE ! condizione di fine ricorsione
11      Result = 1
12   END IF
13
14   END SUBROUTINE Factorial
External Procedure Interfaces

‘program units’ interfacciabili esplicitamente con procedure esterne,
attraverso gli interface blocks:
1   INTERFACE
2      SUBROUTINE MiaSubroutine(scale,x,y)
3      REAL, INTENT(IN) :: x, y
4      REAL, INTENT(IN), OPTIONAL :: scale
5      END SUBROUTINE MiaSubroutine
6   END INTERFACE

interfacce esplicite obbligatorie per external procedures con:

    • argomenti opzionali e keyword

    • argomenti di tipo puntatore o ‘puntati’da puntatore

    • argomenti di tipo array passati secondo il nuovo formalismo

    • funzioni che ritornano arrays o puntatori
Array sintax

assegnazioni (lvalue ← rvalue) aventi degli arrays come oggetti:
1   REAL, DIMENSION(10,10) :: A, B
2   REAL, DIMENSION(0:9,0:9) :: C
3   REAL, DIMENSION(100) :: D
4   REAL :: x = 1.0 ! new
5    A = 10.0 ! scalar conformance
6    B = A    ! shape conformance
7    B = 2*B ! shape conformance
8    D = B    ! Invalid


‘elemental’ operations:
    C = x*A + B*B

array sectioning:
    PRINT*, A(2:4,2:6:2)
    D(:10) = C(:,5) ; B(:,10:1:-1) = C(:,:)

‘intrinsic’ functions che ritornano arrays:
    C = SIN(A) ; D(:10) = ABS(C(:,5))
Nuove classi di arrays

deferred shape arrays (allocati nello heap):


1    INTEGER :: n
2    REAL, DIMENSION(:),   ALLOCATABLE :: x
3    REAL, DIMENSION(:,:), ALLOCATABLE :: tmp(:,:)
4     ...
5    READ*, n ! dimensione nota solo durante l’esecuzione
6     ...
7    ALLOCATE(x(n), tmp(n,0:2*n-1))
8     ...
9    DEALLOCATE(x, tmp)
10    ...
Nuove classi di arrays (II)

assumed shape arrays:
1   SUBROUTINE Sub1(A,B,X)
2   IMPLICIT NONE
3   REAL, DIMENSION(:,:) :: A
4   REAL, DIMENSION(:)   :: B, X
5    ...

automatic arrays:
1   SUBROUTINE Sub2(X,Y)
2   IMPLICIT NONE
3   REAL, INTENT(IN), DIMENSION(:) :: X, Y
4   REAL, DIMENSION(2*SIZE(X)) :: workspace
5    ...
Masked Array Assignment

operazioni su elementi selezionati di un array,
un test logico viene effettuato elemento per elemento → mask
1   INTEGER, DIMENSION(5) :: A, B, C
2   DATA A / 0, 1, 1, 1, 0/
3   DATA B /10,11,12,13,14/
4   C = -1
5   WHERE(A /= 0) C = B / A ! STATEMENT


                             a
il contenuto dell’array C sar`: -1,11,12,13,-1


1   REAL,     DIMENSION(1000) :: Pressure, Temp
2   LOGICAL, DIMENSION(1000) :: Precipitation
3    ...
4   WHERE (Pressure >= 1.0) ! CONSTRUCT
5      Pressure = Pressure + 1.0
6      Temp = Temp - 10.0
7   ELSEWHERE
8      Precipitation = .TRUE.
9   END WHERE
Nuove Array Intrinsic Functions

                  a
Vasta functionalit`

  • inquiry functions: LBOUND, UBOUND, SIZE etc.

  • shape changing functions: RESHAPE, SPREAD etc.

  • reduction functions: SUM, PRODUCT etc.

  • rearrangement functions: EOSHIFT, CSHIFT etc.

  • mask manipulation functions: ALL, ANY, COUNT etc.

  • funzioni matematiche (come in Fortran 77): SIN, LOG etc
     a
Entit` definite dall’utente

definizione di un nuovo tipo:
  TYPE person
     CHARACTER(LEN=20) :: name
     INTEGER :: age
     REAL :: height
  END TYPE person
  TYPE couple
     TYPE(person) :: he, she
  END TYPE couple

dichiarazione di una struttura:
  TYPE(person) :: him, her
  TYPE(couple) :: joneses

selezione dei componenti:
  him%age ; her%name ; joneses%he%height

‘costruttori’ di strutture (come in C++):
him = person(’Jones’, 45, 5.8) ; them = couple(person(...),person(...))
Operatori e procedure generiche

operator overload ed assignment overload:
1   INTERFACE OPERATOR (+)
2      ... ! what + means in this context
3   END INTERFACE ! OPERATOR (+)
4   INTERFACE ASSIGNMENT (=)
5      ... ! what = means in this context
6   END INTERFACE ! ASSIGNMENT (=)
7   ...
8   joneses = him + her


operatori definiti da utente:
1   INTERFACE OPERATOR (.YOUNGER.)
2       ... ! what .YOUNGER. means
3   END INTERFACE ! OPERATOR (.YOUNGER.)
4   ...
5   IF (him.YOUNGER.her) ...
Program Packaging attraverso i Moduli

con MODULE si costruiscono program units contenenti:

  • definizioni di tipi utente, dichiarazioni di costanti, dichiarazioni di
    variabili ed eventuali inizializzazioni

  • statements di accessibilit`, PUBLIC, PRIVATE
                              a

  • definizioni di procedure e funzioni e di interface blocks

  • dichiarazioni di nomi di procedure generiche e di simboli di nuovi
    operatori

lo statement USE:

  • indica il particulare MODULE utilizzato in una program unit

  • importa oggetti ‘publici’

il global storage di variabili con i moduli rende le aree COMMON obsolete
Esempio: uno ‘stack’

1    MODULE stack
2      IMPLICIT NONE
3      PRIVATE
4      INTEGER, PARAMETER :: stack_size = 100
5      INTEGER, SAVE :: store(stack_size), pos = 0
6      PUBLIC push, pop
7    CONTAINS
8      SUBROUTINE push(i)
9        INTEGER, INTENT(IN) :: i
10       IF (pos < stack_size) THEN
11         pos = pos + 1; store(pos) = i
12       ELSE
13         STOP ’Stack Full error’
14       END IF
15     END SUBROUTINE push
16     SUBROUTINE pop(i)
17       INTEGER, INTENT(OUT) :: i
18       IF (pos > 0) THEN
19         i = store(pos); pos = pos - 1
20       ELSE
21         STOP ’Stack Empty error’
22       END IF
23     END SUBROUTINE pop
24   END MODULE stack
Esempio: aritmetica razionale
 1   MODULE RATIONAL_ARITHMETIC
 2     TYPE RATNUM
 3       INTEGER :: num, den
 4     END TYPE RATNUM
 5     INTERFACE OPERATOR(*)
 6       MODULE PROCEDURE rat_rat, int_rat, rat_int
 7     END INTERFACE
 8     PRIVATE :: rat_rat, int_rat, rat_int
 9   CONTAINS
10     TYPE(RATNUM) FUNCTION rat_rat(l,r)
11       TYPE(RATNUM), INTENT(IN) :: l,r
12       rat_rat%num = l%num * r%num
13       rat_rat%den = l%den * r%den
14     END FUNCTION rat_rat
15     TYPE(RATNUM) FUNCTION int_rat(l,r)
16       INTEGER, INTENT(IN) :: l
17       TYPE(RATNUM), INTENT(IN) :: r
18       ...
19     END FUNCTION int_rat
20     TYPE(RATNUM) FUNCTION rat_int(l,r)
21       ...
22     END FUNCTION rat_int
23   END MODULE RATIONAL_ARITHMETIC


 1   PROGRAM Main;
 2   USE RATIONAL_ARITHMETIC
 3   INTEGER :: i = 32
 4   TYPE(RATNUM) :: a,b,c
 5   a = RATNUM(1,16); b = 2*a; c = 3*b
 6   b = a*i*b*c; PRINT*, b
 7   END PROGRAM Main
Esempio: intersezione tra cerchi

definizione di un modulo:
 1   MODULE circles
 2     IMPLICIT NONE
 3     PRIVATE
 4     TYPE, PUBLIC :: POINT
 5       REAL :: x,y
 6     END TYPE POINT
 7     TYPE, PUBLIC :: CIRCLE
 8       TYPE(POINT) :: centre
 9       REAL :: radius
10     END TYPE CIRCLE
11     INTERFACE OPERATOR (.CROSSES.)
12       MODULE PROCEDURE circle_crosses
13     END INTERFACE
14     PUBLIC OPERATOR (.CROSSES.)
15   CONTAINS
16     LOGICAL FUNCTION circle_crosses( c1,c2 )
17       TYPE(CIRCLE), INTENT(IN) :: c1,c2
18       REAL :: d
19       d = (c1%centre%x - c2%centre%x)**2 + &
20           (c1%centre%y - c2%centre%y)**2
21       IF( d < (c1%radius + c2%radius)**2 .OR. &
22           d > (c1%radius - c2%radius)**2 ) THEN
23         circle_crosses = .TRUE.
24       ELSE
25        circle_crosses = .FALSE.
26       END IF
27     END FUNCTION circle_crosses
28   END MODULE circles
Esempio: intersezione tra cerchi (II)

programma utilizzatore del modulo:
1    PROGRAM Example
2      USE circles
3      TYPE(CIRCLE), DIMENSION(8) :: c
4      INTEGER :: Xings=0
5      ... ! read in data c(1:8)
6      DO I= 1,8
7        DO J = 1, I-1
8          IF( c(I) .CROSSES. c(J) ) THEN
9            PRINT*, I, ’ crosses ’, J
10           Xings = Xings + 1
11         END IF
12       END DO
13     END DO
14     PRINT*, ’’Num circles which cross = ’’, Xings
15   END PROGRAM
Puntatori

 • oggetti dichiarati con attributo POINTER:
       REAL, DIMENSION(:,:), POINTER :: ptr_a, ptr_b
         e
   ptr_a ` il ‘descrittore’ di un array 2D di numeri reali

 • gli oggetti ‘referenziati’ (puntati) devono avere attributo TARGET:
       REAL, DIMENSION(-10:10,-10:10), TARGET :: a, b

 • un puntatore ` associato a porzioni di memoria tramite allocazione:
                e
      INTEGER :: N, ierr = 0
      ALLOCATE( ptr_b( 0:N, 0:2*N*N ), STAT=ierr )
      IF ( ierr /= 0 ) STOP ’Allocation failed!’

 • assegnazioni con puntatori:
   ptr_a => a(k:k,j:j)       ! pointer assignment statement
         e
   ptr_a ` ora sinonimo di una parte dell’array a

 • ‘dereferencing’: utilizzo di puntatori al posto dei loro targets:
       ptr_a(15:25,5:15) = ptr_a(10:20,0:10) + 1.0
Puntatori e strutture dati ricorsive

strutture dati con componenti di tipo puntatore strutture dati ‘ricorsive’,
esempio → linked lists:
TYPE CELL
   INTEGER :: val
   TYPE (CELL), POINTER :: p_next
END TYPE CELL

assegnazioni tra strutture sati contenenti puntatori:
TYPE(CELL) :: A
TYPE(CELL), TARGET :: B
  A = B

e
` equivalente a:
  A%val = B%val
  A%p_next => B%p_next      ! dereferencing a II membro

A%p_next punta al target puntato da B%p_next
Tipi di dati parametrizzati

tipi di dati intrinseci (interi, reali, complessi) parametrizzabili a seconda
dell’accuratezza e del range richiesti:
1   INTEGER, PARAMETER   :: k= ... , long = ...
2   INTEGER(KIND=2) ::   i
3   INTEGER(KIND=k) ::   j
4   REAL   (KIND=long)   :: x
5   COMPLEX(KIND=long)   :: c


dove k e long sono delle costanti chiamate ‘kind values’ si possono
esprimere delle costanti anche con il formalismo:
    24_2, 207_k, 1.08_long

variabili di tipo COMPLEX vengono specificate analogamente:
1   INTEGER, PARAMETER :: r2 = 2
2   REAL   (KIND=r2) :: x, y, ...
3   COMPLEX(KIND=long) :: inferiority = (100.0_r2,99.0_r2)


entrambe le parti del numero complesso hanno lo stesso range numerico
True Portability

le funzioni intrinseche SELECTED_INT_KIND e SELECTED_REAL_KIND supportano
i cosiddetti ‘portable data types’
 kind_number = SELECTED_INTEGER_KIND( r = <range> )
 kind_number = SELECTED_REAL_KIND( p = <precision>, r = <range> )

esempio:
1        INTEGER, PARAMETER :: k = SELECTED_INT_KIND(2)
2        INTEGER, PARAMETER :: long = &
3                    SELECTED_REAL_KIND( p=12, r=68 )

    KIND=k determina il tipo intero nel range (−102 , 102 )

    KIND=long determina il tipo reale con un’accuratezza a 12 cifre decimali ed
       un range (−1068 , −10−68 ) ∪ (+10−68 , +10+68 )

⇒ definire sempre delle costanti globali di tipo kind value e renderle visibili
attraverso un modulo !
Nuove caratteristiche di I/O

 • normalmente il Fortran avanza sempre al record successivo nelle
   operazioni di lettura o scrittura, READ, WRITE

 • il Fortran 90 supporta la cosiddetta ‘non–advancing form’ in operazioni
   di I/O

 • esempi:
      WRITE(...,ADVANCE=’NO’,...) a
   accoda il carattere di output al record corrente
      READ(...,ADVANCE=’NO’,...) a
   legge il carattere successivo in un file
      READ(...,ADVANCE=’NO’,EOR=99,SIZE=nch) a
      ...
      99 STOP ’Reached end of record !’
   determina la fine del record ed nch contiene il numero di caratteri
   effettivamente letti
Vantaggi del Fortran 90

              e
il Fortran 90 ` un linguaggio:
    • pi` naturale
        u
    • pi` flessibile
        u
    • pi` sicuro
        u
    • adatto alla parallelizzazione di algoritmi
    • altamente portabile

   e
ma ` anche:
    • pi` vasto
        u
    • complesso ( ...? )
Caratteristiche obsolescenti

lo standard Fortran 90 ha delle caratteristiche definite ‘obsolescenti’ e
   destinate a scomparire dalle prossime versioni ⇒ evitarne l’uso!

alcune caratteristiche obsolescenti:
    • IF aritmetico
    • ASSIGN, ASSIGNed GOTO, ASSIGNed FORMAT statements
    • stringhe in formato Hollerith
    • PAUSE statement
    • contatori di DO loops reali o in doppia precisione
    • ‘alternate RETURN’ statements
    • ed altre ancora ...
Stili di programmazione da evitare


 • fixed source form layout ⇒ usare i free form

 • dichiarazioni implicite di variabili ⇒ usare IMPLICIT NONE

 • blocchi COMMON ⇒ usare MODULE

 • assumed size arrays ⇒ usare gli assumed shape arrays con i MODULE

 • EQUIVALENCE statements

 • ENTRY statements

 • computed GOTO ⇒ usare il costrutto IF
Fine...

 Esercizio: procurarsi un compilatore Fortran ;-)

 Esercizio: immettere da tastiera una serie di numeri reali, massimo 100,
   allocarli in memoria con un array monodimensionale e (a) calcolarne i
   valori massimo e minimo, la media e la deviazione standard; (b) scrivere
   su file i valori immessi e le grandezze calcolate.

 Esercizio: data una matrice di numeri reali, quadrata, con un massimo di
   20 righe, (a) estrarre e stampare le colonne di indice dispari; (b) estrarre
   e stampare gli elementi al di sopra della, e sulla, diagonale principale.

Per un approfondimento: S. J. Chapman, “Fortran 90/95 for Scientists and
Engineers”, WBC/McGraw–Hill, 1998.

								
To top