Quelltext der Seite Fortran: Fortran 2003: Intrinsische Module

<noinclude>
{{:Fortran:Vorlage: NavigationUS|[[Fortran:_Fortran_2003| Fortran 2003]]|[[Fortran:_Bibliotheken|Bibliotheken]]|[[Fortran: Fortran 2003: Intrinsische Funktionen und Subroutinen|Intrinsische Funktionen und Subroutinen]]|[[Fortran: Fortran 2003: OOP|OOP]]}}
</noinclude>
----


== Grundlegendes ==
Module gab es bereits mit ''Fortran 90/95''. Neu in ''Fortran 2003'' sind die sogenannten ''"intrinsischen Module"''. Das sind jene Module, die bereits standardmäßig von Fortran-2003-Compilern bereitgestellt werden. Werden Datenelemente oder Funktionen aus solchen ''intrinsischen Modulen'' benötigt, so ist das entsprechende Modul mittels 

{| {{:Fortran:Vorlage: Table}}
|  use, intrinsic :: ''modulname''
|}

in die jeweilige Programmeinheit einzubinden.

Der Unterschied zu konventionellen (nonintrinsischen) Modulen ist das Wörtchen <code>intrinsic</code>, das dem Compiler mitteilt, dass er das Modul bereits mitbringt und nicht irgendwo extern danach suchen soll. Wird nach dem <code>use</code>-Schlüsselwort kein entsprechendes Attribut oder das <code>non_intrinsic</code>-Attribut angegeben, so zeigt dies an, dass ein nonintrinsisches Modul benutzt wird.

== Das intrinsische Modul <code>iso_fortran_env</code> ==
Das <code>iso_fortran_env</code>-Modul enthält einige Fortran-umgebungsspezifische Konstanten.

Beispiel:

{{:Fortran:Vorlage: Pre4|<pre style="border:0px">
program bsp
  use, intrinsic :: iso_fortran_env
  implicit none 

  write( *, * ) INPUT_UNIT
  write( *, * ) OUTPUT_UNIT
  write( *, * ) ERROR_UNIT
  write( *, * ) IOSTAT_END
  write( *, * ) IOSTAT_EOR
  write( *, * ) NUMERIC_STORAGE_SIZE
  write( *, * ) CHARACTER_STORAGE_SIZE
  write( *, * ) FILE_STORAGE_SIZE  

! Ausgabe, z.B.:
!   5
!   6
!   0
!   -1
!   -2
!   32
!   8
!   8
end program bsp
</pre>
}}


Erläuterung:
{| {{:Fortran:Vorlage: Table}}
! Konstante
! Anmerkung
|-
|- 
| INPUT_UNIT             || Standard-Eingabeeinheit (entspricht <code>unit=*</code> bei <code>read</code>)
|-
| OUTPUT_UNIT            || Standard-Ausgabeeinheit (entspricht <code>unit=*</code> bei <code>write</code>)
|-
| ERROR_UNIT             || Standard-Fehlerausgabeeinheit
|-
| IOSTAT_END             || end-of-file (EOF)
|- 
| IOSTAT_EOR             || end-of-record (EOR)
|-
| NUMERIC_STORAGE_SIZE   || Speicherplatzbedarf (in bits)
|-  
| CHARACTER_STORAGE_SIZE || Speicherplatzbedarf (in bits)
|-
| FILE_STORAGE_SIZE      || Speicherplatzbedarf (in bits)
|}

All diese Konstanten sind Skalare vom Datentyp <code>integer</code>.

Des Weiteren können mittels <code>INTEGER_KINDS, REAL_KINDS, LOGICAL_KINDS</code> und <code>CHARACTER_KINDS</code> die auf dem jeweiligen System verfügbaren kind-Parameter ermittelt werden.

Beispiel:
{{:Fortran:Vorlage: Pre4|<pre style="border:0px">
program bsp
  use, intrinsic :: iso_fortran_env
  implicit none

  print *, "integer_kinds =   ", INTEGER_KINDS
  print *, "real_kinds =      ", REAL_KINDS
  print *, "logical_kinds =   ", LOGICAL_KINDS
  print *, "character_kinds = ", CHARACTER_KINDS

! Ausgabe, z.B.:
! integer_kinds =              1           2           4           8
! real_kinds =                 4           8          10          16
! logical_kinds =              1           2           4           8
! character_kinds =            1           4

end program bsp
</pre>
}}

Beispiel (Ausgabe eines Unicode-Zeichens, siehe auch [https://cyber.dabamos.de/programming/modernfortran/unicode.html Programming in Modern Fortran - Unicode]):
{{:Fortran:Vorlage: Pre4|<pre style="border:0px">
program bsp
    use, intrinsic :: iso_fortran_env, only: output_unit
    implicit none
    
    integer, parameter :: iso_10646 = selected_char_kind('ISO_10646')
    character(kind=iso_10646) :: c
  
    ! Das €-Zeichen
    c = iso_10646_'\u20AC'

    open (output_unit, encoding='UTF-8')
    print *, c

    ! Ausgabe:
    !   €
end program bsp
</pre>
}}

Compiler-Aufruf:
 gfortran.exe bsp.f08 -fbackslash

Die Compiler-Option <code>-fbackslash</code> übersetzt u.a. <code>\xnn, \unnnn</code> und <code>\Unnnnnnnn</code> (n sind hexadezimale Ziffern) in Unicode-Zeichen. Steht diese Option in einem Compiler nicht zur Verfügung, so gibt es auch noch andere Möglichkeiten Unicode-Zeichen zu verarbeiten. Details dazu siehe unter obenstehenden Link.

== Das intrinsische Modul <code>iso_c_binding</code> ==
Das <code>iso_c_binding</code>-Modul liefert die Konstanten und Unterprogramme, die für die Einbindung von C-Bibliotheken in Fortran-Programme erforderlich sind. Näheres dazu findet sich im Kapitel [[Fortran: Fortran und C: Fortran 2003|Fortran 2003 und C]].

== Die intrinsischen IEEE-Module ==
Die bereits aus dem dem TR 15580 : 1998 (floating-point exception handling) bekannten Module 

* <code>ieee_exceptions</code>
* <code>ieee_arithmetic</code>
* <code>ieee_features</code>

wurden in ''Fortran 2003'' in Form von intrinsischen Modulen aufgenommen. Diese Module decken den IEEE&nbsp; 754-1985-Standard (auch IEC&nbsp;559:1989) ab.

=== Wovon handelt der IEEE 754-1985-Standard? ===
Im Bereich der Gleitkommazahlen (<code>real</code>, <code>float</code>, ...) herrschte bis in die 1980er-Jahre Anarchie. Es gab keine verbindlichen Regeln wie Gleitkommazahlen repräsentiert werden, wie gerundet wird, wie Under- und Overflows gehandhabt werden, wie mit Unendlich und NaN verfahren wird, etc. Das führte dazu, dass das gleiche Computerprogramm auf unterschiedlichen Rechnerarchitekturen und mit verschiedenen Compilern unterschiedliche Resultate liefern konnte. Um diesem Manko zu begegnen wurde in den frühen 1980er-Jahren eine Standardisierung angestrebt. Resultat war die Verabschiedung des IEEE 754-1985-Standards (IEEE Standard for Binary Floating-Point Arithmetic for microprocessor systems).  

Dieser Standard regelt im Wesentlichen 
* die Repräsentation von Gleitkommazahlen:
<div style="margin-left:50px">
Darstellung: <math>zahl = (-1)^s\cdot m\cdot b^e</math>
{| style="margin-left:25px"
| s || ... || Vorzeichen
|-
| m || ... || Mantisse
|-
| b || ... || Basis (2 für normalisierte Zahlen)
|-
| e || ... || Exponent
|-
| [[Image:IEEE-754-single.svg|300px]]
|}

Zahlenformate:
{| style="margin-left:25px"
| single             || ... || 4 Bytes
|-
| double             || ... || 8 Bytes
|-
| double-extended    || ... || &ge;10 Bytes, optional
|}
</div>
* die Darstellung normalisierter und denormalisierter Zahlen:
** Normalisierte Zahlen: {{W|Gleitkommazahlen#Normalisierung}}
** Denormalisierte Zahlen: Bereich zwischen der kleinsten darstellbaren normalisierten Zahl und Null (Exponent hat einen reservierten Wert, führende Bit der Mantisse ist 0)
* NaN (Not a Number), <math>\pm \infty</math> , <math>\pm 0</math>
* Rundungen (zur nächstgelegenen darstellbaren Zahl, in Richtung Null, in Richtung <math>+\infty</math> oder in Richtung <math>-\infty</math>)
* das Verhalten verschiedener Operationen (Grundrechenarten, Wurzelberechnung, Konvertierung Gleitkommazahl &rarr; Ganzzahl, Binär-Dezimal-Konvertierung, Vergleiche mit Nan und <math>\infty</math>, etc.)
* Exception-Handling (Overflow, Underflow, Division by Zero, Inexact, Invalid)  


Weiterführende Weblinks:
* {{W|IEEE 754}}
* Kahan, W.: Why do we need a floating-point arithmetic standard?, UC Berkeley, 1981, [http://http.cs.berkeley.edu/~wkahan/ieee754status/why-ieee.pdf]
* Kahan, W.: Lecture Notes on the Status of IEEE Standard 754 for Binary Floating-Point Arithmetic, UC Berkeley, 1996, [http://http.cs.berkeley.edu/~wkahan/ieee754status/IEEE754.PDF]

=== Implementierung in Fortran 2003 ===
Wie bereits erwähnt, besitzt Fortran 2003 intrinsische Module, mit denen der Zugriff auf bestimmte IEEE-Eigenschaften erfolgen kann. Dazu stehen eine Reihe von Funktionen, Subroutinen, Verbundtypen und Konstanten zur Verfügung. Merkmal ist, dass diese immer mit dem Präfix <code>ieee</code> beginnen. 

====<code>ieee_arithmetic</code>====
Das aus Programmiersicht umfangreichste Modul ist sicherlich <code>ieee_arithmetic</code>. Dieses enthält zahlreiche Funktionen, Subroutinen und Konstanten.

Abfragefunktionen für die Unterstützung bestimmter IEEE-Elemente, z.B.:
{| {{prettytable}}
|
 l = ieee_support_datatype( [x] ) 
| Prüft ob die IEEE-Arithmetik für einen speziellen <code>real</code>-Datentyps, charakterisiert durch <code>x</code> (Zahl oder Feld), unterstützt wird. Wird kein Argument angegeben, so wird geprüft, ob die IEEE-Arithmetik für alle <code>real</code>-Datentypen unterstützt wird.
|-
|
 l = ieee_support_nan( [x] ) 
| Prüft, ob NaN-Werte unterstützt werden
|-
|
 l = ieee_support_rounding( round_value, [x] ) 
| Prüft, ob ein bestimmter IEEE-Rundungsmodus unterstützt wird. Mögliche Rundungsmodi sind:
* <code>ieee_nearest</code>
* <code>ieee_to_zero</code>
* <code>ieee_up</code>
* <code>ieee_down</code>
* <code>ieee_other</code> 
|}

Elementare Funktionen, z.B.:
{| {{prettytable}}
|
 l = ieee_is_finite( x )
| Prüft, ob der Wert <code>x</code> endlich ist
|-
|
 r = ieee_next_after( x, y )
| Liefert die nächste darstellbare Zahl von <code>x</code> in Richtung <code>y</code>
|-
|
 r = ieee_rint( x )
| Rundet gemäß eingestelltem Rundungsmodus zu einer Ganzzahl und liefert diese Zahl mit dem Datentyp von <code>x</code> zurück. 

|}

Die Kind-Funktion:
{| {{prettytable}}
|
 r = ieee_selected_real_kind( [p, r] )
| Liefert einen kind-Wert
|}

Nichtelementare Subroutinen, z.B.:
{| {{prettytable}}
|
 ieee_get_underflow_mode( gradual )
| Liefert den aktuellen Underflow-Modus
|-
|
 ieee_set_rounding_mode( round_value )
| Setzt den IEEE-Rundungsmodus, mögliche Werte für <code>round_value</code>
* <code>ieee_nearest</code>
* <code>ieee_to_zero</code>
* <code>ieee_up</code>
* <code>ieee_down</code>
* <code>ieee_other</code>
|}

====<code>ieee_exceptions</code>====
Das <code>ieee_exceptions</code>-Modul enthält zwei Funktionen, mit denen abgefragt werden kann, welche Exceptions unterstützt werden bzw. inwieweit IEEE-Halting unterstützt wird:
 
 l = ieee_support_flag( flag, [x] )
 l = ieee_support_halting( flag )

Mögliche Flags sind
* <code>ieee_invalid</code>
* <code>ieee_overflow</code>
* <code>ieee_divide_by_zero</code>
* <code>ieee_underflow</code>
* <code>ieee_inexact</code>

Des Weiteren sind in diesem Modul einige Subroutinen zum Setzen bzw. Abfragen diverser Flags enthalten:

 ieee_get_status( status_value )
 ieee_set_flag( flag, flag_value )
 ieee_set_halting_mode( flag, halting )
 ieee_set_status( status_value ) 


Bei Einbindung des <code>ieee_arithmetic</code>-Moduls ist auch automatisch Zugriff auf die <code>public</code>-Elemente des Moduls <code>ieee_exceptions</code> gegeben.

====<code>ieee_features</code>====
Das <code>ieee_features</code>-Modul liefert einige benannte Konstanten, z.B. <code>ieee_datatype</code>, <code>ieee_inf</code>, <code>ieee_sqrt</code>.

==== Beispiel: Rundungsmodus ====
IEEE-Subroutinen:
 ieee_get_rounding_mode( val )
 ieee_set_rounding_mode( flag )

Mögliche Wert für <code>flag</code> sind:
{|
| 
* <code>ieee_nearest</code> 
| ... 
| default, Rundung zur nächstgelegenen Zahl (wenn das nicht eindeutig möglich ist, dann Rundung zur nächstgelegenen geraden Zahl)
|-
|
* <code>ieee_to_zero</code> 
| ... 
| Rundung in Richtung 0
|-
|
* <code>ieee_down</code> 
| ... 
| Rundung Richtung <math>-\infty</math>
|-
|
* <code>ieee_up</code> 
| ... 
| Rundung Richtung <math>+\infty</math>
|}

{{:Fortran:Vorlage: Pre4|<pre style="border:0px">
program bsp
  use, intrinsic :: ieee_arithmetic

  implicit none
  
  real, dimension(6)    :: a = (/ -1.5, -0.5, 0.5, 1.5, 2.5, 3.5 /)
 
! Standard-Fortran-Rundungsfunktion
  write( *, * ) anint( a )  

! IEEE-Rundungsfunktion (default)
  write( *, * ) ieee_rint( a )  
  
! IEEE-Rundungsfunktion mit Flag ieee_round_type = ieee_nearest  
  call ieee_set_rounding_mode( ieee_nearest )
  write( *, * ) ieee_rint( a )  
  
! IEEE-Rundungsfunktion mit Flag ieee_round_type = ieee_to_zero  
  call ieee_set_rounding_mode( ieee_to_zero )
  write( *, * ) ieee_rint( a )  

! IEEE-Rundungsfunktion mit Flag ieee_round_type = ieee_down  
  call ieee_set_rounding_mode( ieee_down )
  write( *, * ) ieee_rint( a )  

! IEEE-Rundungsfunktion mit Flag ieee_round_type = ieee_up  
  call ieee_set_rounding_mode( ieee_up )
  write( *, * ) ieee_rint( a )    
end program bsp
</pre>
}}

Ausgabe:
{| {{prettytable}}
! Standard-Fortran
! IEEE-Default 
! ieee_nearest
! ieee_to_zero
! ieee_down
! ieee_up
|-
|
 -2.0 
 -1.0 
  1.0 
  2.0 
  3.0 
  4.0
|
 -2.0 
  0.0
  0.0
  2.0 
  2.0 
  4.0
|
 -2.0 
  0.0
  0.0
  2.0 
  2.0 
  4.0
|
 -1.0 
  0.0
  0.0
  1.0
  2.0 
  3.0
|
 -2.0 
 -1.0 
  0.0
  1.0
  2.0 
  3.0
|
 -1.0 
  0.0
  1.0 
  2.0 
  3.0 
  4.0
|}

====Beispiel: Halting-Modus====
Dieser Modus bestimmt, ob nach einer Exception das Programm angehalten oder fortgesetzt wird. Die in diesem Beispiel eingesetzten IEEE-Unterprogramme sind:

* <code>ieee_support_halting( flag )</code> ... prüft, ob auf dem System das IEEE-Halting für das angegebenen Flag überhaupt unterstützt wird  (Rückgabewert: <code>.true.</code>). Mögliche Flags:
** <code>ieee_invalid</code>
** <code>ieee_overflow</code>
** <code>ieee_divide_by_zero</code>
** <code>ieee_underflow</code>
** <code>ieee_inexact</code>
* <code>ieee_set_halting_mode( flag, mode )</code> ... setzt den Halting-Modus für ein bestimmtes Flag. 
** <code>flag</code> ... wie bei <code>ieee_support_halting( flag )</code>
** <code>mode</code>:
*** <code>.true.</code> ... anhalten
*** <code>.false.</code> ... Programm weiter ausführen


{{:Fortran:Vorlage: Pre4|<pre style="border:0px">
program main
  use, intrinsic :: ieee_arithmetic
  implicit none 
    
  real :: a, b
    
  if( ieee_support_halting( ieee_divide_by_zero ) ) then
    call ieee_set_halting_mode( ieee_divide_by_zero, .false. )
    
    read( *, * ) a, b
    write( *, * ) "Resultat: ", a / b 
    write( *, * ) "Programm wird fortgesetzt ..."      
  else
    write( *, * ) "IEEE-Halting wird nicht unterstuetzt"
  end if  
end program main
</pre>
}}

Eingabe:
* 10.0 (... für a)
* 0.0 (... für b)

Ausgabe (bei Programmerstellung mit dem Sun-Express-Fortran-Compiler f95): 
{| {{prettytable}}
! <code>ieee_set_halting_mode( ieee_divide_by_zero, <span style="color:#009900">.false.</span> )</code>
! <code>ieee_set_halting_mode( ieee_divide_by_zero, <span style="color:#CC00FF">.true.</span> )</code>
|-
|
 Resultat:  Inf
 Programm wird fortgesetzt ...
|
 Gleitkomma-Ausnahme
|}


Weitere Beispiele zum Thema "Exceptions and IEEE arithmetic" sind im Fortran 2003-Working Draft J3/04-007 ab Seite 386 enthalten.


----
<noinclude>
{{:Fortran:Vorlage: NavigationUS|[[Fortran:_Fortran_2003| Fortran 2003]]|[[Fortran:_Bibliotheken|Bibliotheken]]|[[Fortran: Fortran 2003: Intrinsische Funktionen und Subroutinen|Intrinsische Funktionen und Subroutinen]]|[[Fortran: Fortran 2003: OOP|OOP]]}}
</noinclude>