Fortran und Basic by hcw25539

VIEWS: 80 PAGES: 27

									                    Fortran und BASIC
       10 Programmiersprachen in einem Semester




Zitate Fortran
FORTRAN, 'the infantile disorder', by now nearly 20
years old, is hopelessly inadequate for whatever
computer application you have in mind today: it is
now too clumsy, too risky, and too expensive to use.
                                                          Edsger W. Dijkstra


FORTRAN was the language of choice for the same
reason that three-legged races are popular.
                       Ken Thompson (in "Reflections on Trusting Trust")




Fortran und Basic         Patrick Mächler, David Ammann                   2




                                                                               1
Fortran, Hintergründe
FORTRAN bedeutet Formula Translation.

Wurde ab 1954 mit Backus bei IBM entwickelt und
gilt als erste realisierte höhere Programmiersprache.

Der Compiler wurde erst ab 1957 ausgeliefert.

Bisher existieren 8 offizielle Versionen:
FORTRAN I, FORTRAN II, FORTRAN IV, FORTRAN-66,
FORTRAN-77, Fortran90, Fortran95, Fortran2003.

Fortran und Basic   Patrick Mächler, David Ammann   3




Programmstruktur
PROGRAM program-name
  [IMPLICIT NONE]
  [specification part]
  [execution part]
  [subprogram part]
END PROGRAM program-name




Fortran und Basic   Patrick Mächler, David Ammann   4




                                                        2
Kommentare
"!" kommentiert nachfolgende Zeichen

Beispiele:
    READ(*,*) Year ! read in the value of Year
    ! This is a comment line


Leere Zeile wird ebenfalls als Kommentar
  interpretiert.




Fortran und Basic   Patrick Mächler, David Ammann   5




Zeilenfortsetzung
"&" dient zur Zeilenfortsetzung

Beispiel:
    A = 174.5 * Year &
     + Count / 100
    ist dasselbe wie:
    A = 174.5 * Year + Count / 100




Fortran und Basic   Patrick Mächler, David Ammann   6




                                                        3
Konstanten/Datentypen I
• Integer Constants: Folgen von Zahlen mit
  (optionalem) Vorzeichen: 0, -345, 768

• Real Constants (Decimal Representation): Folgen
  von Zahlen und ein Dezimalpunkt mit
  (optionalem) Vorzeichen: 23.45, .123, 123., -.12

• Real Constants (Exponential Representation):
  Integer oder Real (decimal), gefolgt von "E" oder
  "e", gefolgt von einem Integer: 12.34E2, -1.2e-3


Fortran und Basic   Patrick Mächler, David Ammann     7




Konstanten/Datentypen II
• Complex Constants: Bestehend aus zwei Real
  Constants: (3.1415, -5.5), (1.4, 7.1e4)

• Logical Constants: True und False: .TRUE.,
  .FALSE. ("." Beachten!)

• Character String: Müssen durch double quotes
  oder single quotes eingeschlossen werden: 'John',
  "John" (Bem: "Lori's apple" = 'Lori''s apple'



Fortran und Basic   Patrick Mächler, David Ammann     8




                                                          4
Identifiers
• Nicht länger als 31 Zeichen
• Erstes Zeichen muss Buchstabe sein
• Restliche Zeichen (falls vorhanden) bestehend
  aus Buchstaben, Zahlen und dem Unterstrich "_"
• Case insensitive (Smith=smith=sMiTh=smitH)

Beispiele (korrekt):
  MTU, MI, John, Count, I, X, I1025, a1b2C3
Beispiele (inkorrekt):
  M.T.U., R2-D2, 6feet, _System

Fortran und Basic            Patrick Mächler, David Ammann        9




Variablendeklaration I
Allgemein:
    type-specifier :: list


    type-specifier =
                    INTEGER, REAL, COMPLEX, LOGICAL, CHARACTER


    list = kommaseparierte Liste von Variablennamen


Beispiele:
    INTEGER :: ZIP, Mean, Total


Fortran und Basic            Patrick Mächler, David Ammann       10




                                                                      5
Variablendeklaration II
Spezialfall CHARACTER:
    CHARACTER(LEN=i) :: List


Beispiel:
    CHARACTER(LEN=15) :: Name, Street
    Name und Street sind CHARACTER-Variablen der
    Länge 15.

"LEN=" ist optional: CHARACTER(15) :: Name, Street
CHARACTER :: digit entspricht CHARACTER(1) :: digit


Fortran und Basic           Patrick Mächler, David Ammann   11




Variablendeklaration III
Verschiedene Längen mit einem Statement sind
  möglich:
    CHARACTER(LEN=10) :: City, Nation*20, BOX, bug*1


    City:           Länge   =   10
    Nation:         Länge   =   20
    Box:            Länge   =   10
    bug:            Länge   =   1




Fortran und Basic           Patrick Mächler, David Ammann   12




                                                                 6
PARAMETER Attribut
Einer Konstante einen Wert zuweisen

Beispiele
    REAL, PARAMETER :: E = 2.71828, PI = 3.141592

    INTEGER, PARAMETER :: Total = 10, Count = 5, Sum =
     Total*Count


Ein Name, der mit Parameter deklariert wurde, ist
  ein Alias für einen Wert und keine Variable!


Fortran und Basic   Patrick Mächler, David Ammann    13




Variablen initialisieren
Keine Standardinitialisation (z.B. mit 0, "", usw)

• Beispiele:
     REAL :: Offset = 0.1, Length = 10.0

     INTEGER, PARAMETER :: Quantity=10, Amount=435
     INTEGER :: Pay=Quantity*Amount, Received=Period+5
     INTEGER, PARAMETER :: Period=3
     Fehler?




Fortran und Basic   Patrick Mächler, David Ammann    14




                                                          7
Variablen Werte zuweisen
variable = expression


Der Wert rechts von "=" wird der Variable links vom
  "=" zugewiesen

    INTEGER :: Total, Amount, Unit

    Unit = 5
    Amount = 100.99
    Total = Unit * Amount




Fortran und Basic   Patrick Mächler, David Ammann    15




Arrays I
Allgemein
    type, DIMENSION(extent) :: name-1, ..., name-n


Beispiel:
    INTEGER, DIMENSION(0:100) :: InputData
    INTEGER, DIMENSION(10) :: arr
    (Achtung: Index startet hier mit 1!)
    INTEGER :: arr(10)




Fortran und Basic   Patrick Mächler, David Ammann    16




                                                          8
Arrays II
Zugriff auf Array-Elemente:
    array-name ( integer-expression )


Beispiel:
    InputData(2)
    InputData(i*j)
    InputData(3:7)
    usw.




Fortran und Basic    Patrick Mächler, David Ammann      17




Arrays III
Array-Initialisierung:
  Felder lassen sich gleich bei der Deklaration mit
  Werten Initialisieren.

    Eindimensionale Arrays:
    INTEGER :: arr(5) = (/1, 2, 4, 7, 16/)


    Mehrdimensionale Arrays (Befehl "reshape"):
    INTEGER :: arr(2,3)=reshape((/1, 1, 3/),(/2, 3/))




Fortran und Basic    Patrick Mächler, David Ammann      18




                                                             9
Arrays IV
Mehrdimensionale Arrays:
 Allgemein:
    type, DIMENSION(a:b, c:d, ...) :: arr


    Beispiel (2D-Array):
    1 2 3
    4 5 6      soll in einem 2D-Feld gespeichert werden.

    INTEGER :: arr(2,3) = reshape((/1, 2, 3, 4, 5,
    6/),(/2, 3/))
    (Analog für n Dimensionen)

Fortran und Basic        Patrick Mächler, David Ammann     19




Implied DO I
Methode zur raschen Auflistung von vielen
 Elementen:
    (item-1,...., item-n, var = initial, final, step)


Beispiele:
    (i, i = -1, 2) -1, 0, 1, 2
    (i, i*i, i=1, 10, 3) 1, 1, 4, 16, 7, 49, 10, 100




Fortran und Basic        Patrick Mächler, David Ammann     20




                                                                10
Implied DO II
Anwendung: Array Input
    INTEGER, DIMENSION(1:10) :: x
    INTEGER :: n, i

    READ(*,*) n
    DO i = 1, n
     READ(*,*) x(i)
    END DO


Einfacher:
    READ(*,*) n
    READ(*,*) (x(i), i=1, n)


Fortran und Basic       Patrick Mächler, David Ammann                       21




Arithmetische Operatoren
      Typ            Operator                           Assoziativität
      Arithmetisch               **                     rechts nach links
                        *                 /             links nach rechts
                        +                 -             links nach rechts
      Relational     < <= > >= == /= keine
      Logisch                  .NOT.                    rechts nach links
                               .AND.                    links nach rechts
                                .OR.                    links nach rechts
                      .EQV.           .NEQV.            links nach rechts

     • Priorität von oben nach unten: -3**2 = -9


Fortran und Basic       Patrick Mächler, David Ammann                       22




                                                                                 11
Intrinsische Funktionen I
Funktion            Argument Typ                       Rückgabe Typ
ABS(x)              INTEGER/REAL                       INTEGER/REAL
SQRT(x)             REAL                               REAL
SIN(x)              REAL                               REAL
COS(x)              REAL                               REAL
TAN(x)              REAL                               REAL
ASIN(x)             REAL                               REAL
ACOS(x)             REAL                               REAL
ATAN(x)             REAL                               REAL
EXP(x)              REAL                               REAL
LOG(x)              REAL                               REAL


Fortran und Basic      Patrick Mächler, David Ammann                  23




Intrinsische Funktionen II
• Unwandlungsfunktionen:
  REAL   INTEGER: INT(x), NINT(x), FLOOR(x)
  REAL   REAL: FRACTION(x)
  INTEGER   REAL: REAL(x)

• Diverse Funktionen:
  MAX(x1, x2, …, xn), MIN(x1, x2, …, xn),
  MOD(x,y)




Fortran und Basic      Patrick Mächler, David Ammann                  24




                                                                           12
Das READ Statement
Werte von Tastatur in Variablen einlesen:
    READ(*,*) list


    list:     kommaseparierte Liste von Variablen




Fortran und Basic      Patrick Mächler, David Ammann   25




Das READ Statement II
Beispiel:
    INTEGER :: P, Q, R, S
    READ(*,*) P, Q
    READ(*,*)
    READ(*,*) R, S


    Input:
    100 200 300
    400 500 600
    700 800 900


    P=?, Q=?, R=?, S=?
    Lösung: P=100, Q=200, R=700, S=800
Fortran und Basic      Patrick Mächler, David Ammann   26




                                                            13
Das WRITE Statement
Funktioniert wie READ Statement

Allgemein:
    WRITE(*,*) exp1, exp2, ..., expn


    WRITE(*,*)      ohne Argument(e) gibt leere Zeile aus.




Fortran und Basic        Patrick Mächler, David Ammann   27




Character Operators
Es existiert nur ein Character Operator:

    "//" dient zur Verknüpfung von Strings

Beispiele:
    CHARACTER(LEN=*) :: John*4="John", Lori*6="Lori"
    CHARACTER(LEN=10) :: Ans1
    Ans1 = John // Lori


    Ans1 = ?
    Lösung: Ans1 = 'JohnLori**' (* = Space)

Fortran und Basic        Patrick Mächler, David Ammann   28




                                                              14
Substrings
Anfügen von (integer-exp1 : integer-exp2) an eine
  CHARACTER Variable.

Beispiele:
CHARACTER(Len=*) :: LeftHand = "1234567890"
LeftHand(3:5) = "abc"    "12abc67890"
LeftHand(4:) = "lmnopqr"    " 123lmnopqr"




Fortran und Basic       Patrick Mächler, David Ammann   29




IF-THEN-ELSE-END IF I
Allgemeine Form:
    IF (logical-expression) THEN
     statements-1
    ELSE
     statements-2
    END IF


    Else     und statements-2 optional!

Logical IF:
     IF (logical-expression) one-statement


Fortran und Basic       Patrick Mächler, David Ammann   30




                                                             15
IF-THEN-ELSE-END IF II
• Verschachtelte IF-THEN-ELSE-END-IF Statements
  sind möglich.

• ELSE IF ebenfalls möglich:
    IF (logical-expression-1) THEN
     statements-1
    ELSE IF (logical-expression-2) THEN
     statements-2
    ELSE
     statements-ELSE
    END IF




Fortran und Basic   Patrick Mächler, David Ammann   31




SELECT CASE Statement
    SELECT CASE (selector)
        CASE (label-list-1)
              statements-1
        CASE (label-list-2)
              statements-2
        .............
        CASE DEFAULT
              statements-DEFAULT
    END SELECT


Wertebereich für label-list-n: (value1 : value2),
 also zum Beispiel (:-1) für alle negativen Zahlen.


Fortran und Basic   Patrick Mächler, David Ammann   32




                                                         16
General DO-Loop
Allgemein
    DO
     statements
    END DO


"EXIT" verlässt Schleife




Fortran und Basic   Patrick Mächler, David Ammann    33




Counting Do-Loop
Allgemein:
    DO var=initial-value, final-value, [step-size]
     statements
    END DO


Wenn step-size nicht angegeben, wird 1
 genommen.

"CYCLE" beginnt mit nächster Iteration.




Fortran und Basic   Patrick Mächler, David Ammann    34




                                                          17
WHERE
Allgemein:
    WHERE( bedingung ) variable = ausdruck


Beispiel:
    INTEGER :: arr(5) = (/1,2,3,4,5/)
    WRITE(*,*) arr
    ! Ausgabe: 1 2 3 4 5

    WHERE (arr>=3) arr=99999
    WRITE(*,*) arr
    ! Ausgabe: 1 2 99999 99999 99999



Fortran und Basic   Patrick Mächler, David Ammann   35




FORALL
Wie WHERE für Einsatz bei Arrays gedacht,
 Bestimmung der Feldelemente aber über Indizes:

Allgemein:
    INTEGER :: arr(5) = (/1,2,3,4,5/)
    INTEGER :: i

    FORALL(i=2:4)
     arr(i) = 99999
    END
    WRITE(*,*) arr
    ! Ausgabe: 1 99999 99999 99999 5


Fortran und Basic   Patrick Mächler, David Ammann   36




                                                         18
Datenverbund I
Bildung eigener Datentypen aus Fortran-
   Datenelementen:

Allgemein:
    TYPE :: typename
     [sequence] ! opt. seq. Speicherplatzablage

     datentyp :: varname1
     ! ...
     datentyp :: varnamen
    END TYPE typename



Fortran und Basic   Patrick Mächler, David Ammann   37




Datenverbund II
Beispiel:
    TYPE :: PERSON
     CHARACTER(25) :: vorname
     CHARACTER(25) :: nachname
     INTEGER :: alter
    END TYPE PERSON




Fortran und Basic   Patrick Mächler, David Ammann   38




                                                         19
Unterprogramme
Fortran 95 kennt zwei Typen von
  Unterprogrammen:

• Funktionen (FUNCTION): Geben einen Wert von
  bestimmtem Typ zurück.

• Subroutinen (SUBROUTINE): Besitzen im
  Gegensatz zu Funktionen keinen Datentyp und
  Rückgabewert.



Fortran und Basic   Patrick Mächler, David Ammann   39




Funktionen I
Allgemein:
    type FUNCTION function-name (arg1, ..., argn)
     [IMPLICIT NONE]
     [specification part]
     [execution part]
     [subprogram part]
    END FUNCTION function-name


Beinahe identisch mit dem Hauptprogram.




Fortran und Basic   Patrick Mächler, David Ammann   40




                                                         20
Funktionen II
Beispiel:
    INTEGER FUNCTION Sum(a, b, c)
     IMPLICIT NONE
     INTEGER, INTENT(IN) :: a, b, c

     Sum = a + b + c
    END FUNCTION Sum


INTENT(IN)   definiert die Variable als formale
    Argumente. Sie können innerhalb der Funktion
    nicht verändert werden.


Fortran und Basic      Patrick Mächler, David Ammann   41




Funktionen III
Wohin gehören die Functions?
    PROGRAM program-name
     IMPLICIT NONE
     [specification part]
     [execution part]
    CONTAINS
     [your functions]
    END PROGRAM program-name




Fortran und Basic      Patrick Mächler, David Ammann   42




                                                            21
Subroutinen I
Allgemein:
    SUBROUTINE subName ([formal parameters])
     [specification part]
     [execution part]
     [return]
    END SUBROUTINE subName


Aufgerufen werden Subroutinen mit:
    CALL subName




Fortran und Basic     Patrick Mächler, David Ammann             43




Subroutinen II
Beispiel:
    PROGRAM bsp
     CALL sub                                 Datei "bsp.f90"
    END PROGRAM bsp

    SUBROUTINE sub()
     WRITE(*,*) 'Hallo Welt!'                 Datei "sub.f90"
     RETURN
    END SUBROUTINE sub


Kompilieren mittels:
    gfortran bsp.f90 sub.f90


Fortran und Basic     Patrick Mächler, David Ammann             44




                                                                     22
Prozeduren als Parameter I
Prozeduren können als Parameter übergeben
  werden.

Unterprogramme werden dazu im Vereinbarungsteil
  gekennzeichnet:

• Standard-Funktionen: INTRINSIC namensliste

• Eigene Unterprogramme: EXTERNAL namensliste



Fortran und Basic   Patrick Mächler, David Ammann   45




Prozeduren als Parameter II
Beispiel:
    PROGRAM bsp
     REAL, parameter :: PI=3.1415927
     INTRINSIC sin, cos ! intrinsic functions

     CALL sub(sin, PI) ! Ausgabe: 0.000000
     CALL sub(cos, PI) ! Ausgabe: -1.000000
    END PROGRAM bsp

    SUBROUTINE sub(funk, x)
     REAL :: funk, x
     WRITE(*,*) NINT(funk(x)*1000)/1000.0
    END SUBROUTINE


Fortran und Basic   Patrick Mächler, David Ammann   46




                                                         23
File I/O I
In Fortran ist alles, was mit READ und WRITE
  bearbeitbar ist, eine Datei!

Zugriff:
• Sequentiell: Lesen ab Beginn der Datei und dann
  immer nächsten Datensatz. Schreiben an's
  Dateiende.
• Direkt: Bearbeiten in beliebiger Reihenfolge durch
  Angabe der Satznummer.



Fortran und Basic   Patrick Mächler, David Ammann    47




File I/O II
Allgemein:
    open(liste)


liste   (kommasepariert):
    [unit =] x: Dateinummer (Integer > 10)
    file = x:    externer Dateiname
    iostat = x: -1 für EOF, >0 bei Fehler, 0 sonst
    action = x: 'read', 'write' oder 'readwrite'
    access = x: 'sequential', 'direct'
    position = x:   Position des Datensatzzeigers
                 ('asis', 'rewind', 'append')
Fortran und Basic   Patrick Mächler, David Ammann    48




                                                          24
The legacy of FORTRAN
There is a vast body of Fortran in daily use throughout
the scientific and engineering communities. It is the
primary language for some of the most intensive
supercomputing tasks, such as weather/climate modeling,
computational chemistry, quantum chromodynamics and
simulation of automobile crash dynamics. Indeed, one
finds that even today, half a century later, floating-point
benchmarks to gauge the performance of new computer
processors are still written in Fortran (e.g., the floating-
point component of the SPEC CPU2000 benchmarks), an
eloquent tribute to the longevity of the language.
                                             en.wikipedia.org


Fortran und Basic    Patrick Mächler, David Ammann        49




BASIC Hintergründe
BASIC steht für
Beginner’s All-purpose Symbolic Instruction Code
1964 wurde es am Dartmouth College entwickelt,
  um den Elektrotechnikstudenten den Einstieg in
  Algol und Fortran zu erleichtern.
BASIC spielte eine massgeblich Rolle in der Anfangs-
  zeiten der Firma Microsoft.
BASIC kann wohl als die Sprache mit den meisten
  Dialekten bezeichnet werden. Viele neue Dialekte
  erfreuen sich heute grosser Beliebtheit (Profan,
  VisualBasic, Blitzbasic, Darkbasic, Purebasic).

Fortran und Basic    Patrick Mächler, David Ammann        50




                                                                25
BASIC Entwurfsprinzipien
BASIC       liegt acht Entwurfsprinzipien zugrunde:
•  1.       Für Anfänger einfach zu erlernen
•  2.       universell einsetzbar
•  3.       Erweiterbarkeit der Sprache für Experten
•  4.       Interaktivität
•  5.       Klare Fehlermeldungen
•  6.       Rasche Antwortzeiten
•  7.       Hardwareunabhängigkeit
•  8.       Betriebssystemunabhängigkeit


Fortran und Basic      Patrick Mächler, David Ammann   51




Goto I
In Fortan I war Goto neben if-then-else die einzige
  verfügbare Kontrollstruktur. Mit Fortran90 wurde
  Goto komplett abgeschafft.
Auch im ursprünglichen BASIC spielte Goto eine
  wichtige Rolle. Neuere Dialekte verzichten oft auf
  das Konstrukt.
In einem Brief an die Zeitschrift der ACM, Go To
  Statement Considered Harmful (die berühmte
  Phrase stammte von dem damaligen Editor Wirth)
  sprach sich Dijkstra für eine Abschaffung des
  Statements aus, da es zu Spaghetti Code führe.

Fortran und Basic      Patrick Mächler, David Ammann   52




                                                            26
Goto II
Dies löste eine grössere Kontroverse aus, die Knuth
  später mit einer relativ realistischen Betrachtung
  wohl beendete.
Auch in vielen neueren Programmiersprachen lässt
  sich Goto noch finden. Entweder in ursprünglicher
  (C#) oder restriktiver Form (Java: return innerhalb
  einer Methode, break und continue innerhalb einer
  Schleife).

http://www.acm.org/classics/oct95/
http://pplab.snu.ac.kr/courses/adv_pl05/papers/p261-knuth.pdf


Fortran und Basic        Patrick Mächler, David Ammann                       53




Für Übungsblatt relevante
Vergleiche Fortran-Basic
                        BASIC                     FORTRAN
  Kommentare            ;Kommentar                !Kommentar
  Variablendefinition   a$                        CHARACTER(LEN=i) :: a
                        a#                        REAL :: a
                        a bzw. a%                 INTEGER :: a
  Ausgabe               Print                     Write
  Benutzereingabe       Input                     Read
  Kontrollstrukturen    Do/Loop                   Do/Loop
                        For/Next                  Do/Loop
                        While/Wend                Do While/End Do
                        If/Then/Else/Endif        If/Then/Else/End If
                        -                         Where
                        -                         Implied-Do
                        A:/Goto A                 A:/Goto A(vor Fortan 90)



Fortran und Basic        Patrick Mächler, David Ammann                       54




                                                                                  27

								
To top