1 / 38

Fortran 90, 95, and 2000

Fortran 90, 95, and 2000. Fortran 90. Generalities: format changes, portable numerics Arrays: syntax, classes of arrays, dynamic storage Structures Derived types Pointers (not like C/C++ pointers, more like aliases) Type parameterization Modules and interfaces. Fortran-C++ Translations.

hawa
Download Presentation

Fortran 90, 95, and 2000

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Fortran 90, 95, and 2000

  2. Fortran 90 • Generalities: format changes, portable numerics • Arrays: syntax, classes of arrays, dynamic storage • Structures • Derived types • Pointers (not like C/C++ pointers, more like aliases) • Type parameterization • Modules and interfaces

  3. Fortran-C++ Translations • derived type = user-defined type (struct) • module = class (sorta, more in F2k than F95) • scalar = basic entity (real, int, arrays, complex) • functional language = procedural language • extending = subclassing (makes more sense) • use != uses/provides patterns

  4. First the Good News • Alternate returns obsolescent • calling procedure provides alternate places in itself to which a called procedure would return control • Alternate entry points may be obsolescent in F2k • allowed execution start point in a called procedure to be specified by the caller • Multiple ways of doing same thing eliminated • Free (but reported unable to handle some dusty corners): http://www.intel.com/software/products/compilers/f60l/noncom.htm

  5. Fortran 90: General Format changes Free-form (one-line multistatement delimiter ";") Continuation is "&" at the end of the line to be continued F77 required statements in columns 7-71 only Comments start with "!", not "c" Array handling: multidimensional arrays are directly supported constructs. rank of an array is its dimensionality Complex numbers built-in (big performance win over current C++ libraries) Relational Operators ( .eq. is ==, .le. is <=, .ne. is />, etc.)

  6. Fortran 90 Array syntax: you can replace array operations such as do k = 1, n y(k) = y(k) + a*x(k) end do with the one-liner y(1:n) = y(1:n) + a*x(1:n) or, if x and y are exactly of length n, y = y + a*x

  7. Fortran 90 Numerical precision control: If at least 10 decimal digits will be needed and exponents from 10-50 to 10+50, you can declare real(kind=selected_real_kind(10,50)) :: x, y Or you can match the precision with a given constant: integer, parameter:: dbk = kind(1.0d0) real(kind=dbk) :: x, y BEWARE: although a kind is an integer, the mapping between integers and the actual kinds is compiler implementor dependent So avoid real(kind=2) :: x, y

  8. Fortran 90 Array declarations are clearer: real(kind=dbk), dimension(3,4) :: A, B real, dimension(-2:5,3:4) :: C Declares A and B to be 3x4 matrices of datatype real(dbk) with enough precision to match the constant 1.0d0 Declares C to be a 8x2 array, with row indices ranging from -2 to 5 and column indices from 3 to 4 Array bounds are inclusive of each end - unlike Perl which excludes the upper bound.

  9. Fortran 90 Array sections: these work just like in Matlab, but with the stride last. So if real(kind=dbk), dimension(3,5) :: A then the section A(:3:2,1::2) = A(1:3:2,1:5:2) refers to the matrix [A(1,1) A(1,3) A(1,5)] [A(3,1) A(3,3) A(3,5)] Also like Matlab, you can use vector subscripts. So if integer, dimension(2) :: R = (/1,3/) integer, dimension(3) :: C = (/1,3,5/) then the array section A(R,C) is the same as the section A(:3:2,1::2) Can pass such a critter as A(R,C) as argument of a function!

  10. Fortran 90 Array operations may use a mask operation, keyword where: where (x > 0) y = log(x) The general form of the where has an else clause: where (x > 0) y = log(x) elsewhere y = -inf end where What if you call a function with argument x in one of the clauses? All statements within a where must be array assignments

  11. Fortran 90 All the Fortran intrinsic functions can be used with arrays instead of just scalars: do k = 1, n x(k) = y(k) + a*sin(x(k)) end do becomes (if x,y are of conformant length n) x = y + a*sin(x)

  12. Fortran 90: Array Classes Five classes of arrays are possible: explicit shape (also available in F77) assumed-shape automatic assumed size (also available in F77) deferred-shape (allocatable arrays)

  13. Explicit Shape Arrays Explicit shape have their dimensions passed as arguments to a subroutine (or dims passed in via modules, or host info access) subroutine explicit(A,B,m,n) integer, intent(in) :: m,n real, dimension(0:m+1, 0:n+1), intent(inout) :: A real, dimension(m,n,3), intent(out) :: B ... end subroutine explicit The bounds of the actual and dummy arguments need not match Caller could have had real, dimension(m+2,n+2) :: A The extents should match (length of each dimension)

  14. Assumed Shape Arrays Assumed shape have their extents associated with actual arguments when the call is made subroutine assumed(A,B) real, dimension(0:, 0:), intent(inout) :: A real, dimension(:,:,:), intent(out) :: B n = ubound(B, dim=2) -1 end subroutine assumed Actual arg must have same type and have same rank as the dummy arguments Can retrieve lbound, ubound, and size of each dimension.

  15. Automatic Arrays Automatic arrays are explicit shape arrays which are not dummy args and have at least one nonconstant index bound subroutine automatic(B, n) integer :: n real, dimension(0:n+1, 0:n+1) :: A real, dimension(size(B,1)) :: C real, dimension(1000) :: D ! Not an auto array end subroutine automatic Space is allocated dynamically on entry, deallocated on exit Can be passed to other routines in between

  16. Assumed Size Arrays Assumed size are the worst of all. All extents except last must be given explicitly; last is given as * or lower_bound:* Size of actual argument and dummy argument must match Shapes of actual and dummy arguments need not match. So can declare A(10,10,10) and pass to a routine which declares the dummy argument as B(5, *). Deprecated in F90; not sure about status in F2k but likely it will remain.

  17. Fortran 90: Allocatable Arrays program arrayexample integer :: i, j, n, m ! newer style declaration of two integers real, dimension(:,:), allocatable :: A, B, C real, dimension(:) , allocatable :: d, e, f write(*,"('Enter the size of A(n,m) :')", advance='no'); read(*,*) n,m allocate (A(n,m)); allocate (B(m,n)); allocate (C(n,n)) allocate ( e(size(C)) ) ! Creates rank-1 array of length n*n call define_AB( A, B, n, m ) ! user-defined setup of matrices A and B C = matmul( A, B ) ! intrinsic function matrix multiply print *, 'C = ' ! Output of entire array C with some default formatting deallocate(A) ! deallocation order not important ... end program arrayexample

  18. Modules and Derived Types module rational_arithmetic type ratnum integer :: num, den end type ratnum interface operator(*) module procedure rat_rat, int_rat, rat_int end interface private :: rat_rat, int_rat, rat_int contains type(ratnum) function rat_rat(l,r) type(ratnum), intent(in) :: l,r rat_rat%num = l%num * r%num rat_rat%den = l%den * r%den end function rat_rat type(ratnum) function int_rat(l,r) type(ratnum), intent(in) :: r integer, intent(in) :: l ... end function int_rat end module rational_arithmetic program main use rational_arithmetic integer :: i = 32 type(ratnum) :: a,b,c a = ratnum(1,16); b = 2*a; c = b*3 b = a*i*b*c end program main

  19. Modules and Derived Types A derived type can have a further derived type the type currently being declared (usual linked list data structure mechanism) sequence attribute can force storage locations User defined types cannot contain allocatable entities restriction may disappear in F2k

  20. Pointers ptr => y ! pointer assignment (aliasing) ptr = x ! value assignment; sets y = x nullify(ptr) ! disassociate ptr and y Thing pointed at must have the target attribute real, dimension(1:n,1:n), target :: A

  21. Pointers real, dimension(:,:), pointer :: pa, pb pa is a ptr for a 2D array of reals can associate memory with a ptr allocate(prb(0:n,0:2*n*n), stat=ierr) pa => A(-k:k,-j:j) pa is now an alias for (part of) A. Pointers are automatically dereferenced pa(15:25,5:15) = pa(10:20,0:10) + 1.0

  22. Optional Arguments subroutine optargs(scale, x) real, intent(in) :: x real, intent(in), optional :: scale real :: actual_scale actual_scale = 1.0 if (present(scale)) actual_scale = scale ... end subroutine optargs

  23. Interface Blocks interface subroutine assumed(A, B) real, dimension(-1:, -1:), intent(inout) :: A real, dimension(:,:,:), intent(out) :: B end subroutine assumed end interface Mandatory for external non-module procs with optional and keyword arguments pointer and target arguments assumed shape or sliced array arguments array or pointer valued procedures

  24. Function Overloading User defined overload set interface zero module procedure zero_int module procedure zero_real end interface zero Generic name zero is associated with specific names zero_int and zero_real One called is based on argument signature

  25. Fortran 90 Array Intrinsics all(mask, dim) : true if all values are true cshift(array, shift, dim) : circular shift dot_product(A, B) : dot product of tworank-one arrays matmul(A, B) : A*B, if conformant and at least one is rank-2 (no vector outer product) maxval(array, dim, mask) : maximum value of array merge(tsource, fsource, mask) : combining two arrays using a mask maxloc(array, mask) : location of element with maximum value spread(source, dim, ncopies) : replicate an array by adding a dimension sum(array, dim, mask) : sum array elements transpose(matrix) : transpose array of rank two

  26. Fortran 95 Features • Minor enhancements over F90: • forall statement and construct • pure and elemental procedures • pure means no side effects; prefix for function • elemental means pure function with only scalar dummy arguments. Can then be called with conformant array actual arguments, and it operates componentwise. • structure and pointer default initialization

  27. Fortran 2004 • Fortran standard is multi-part (ISO/IEC 1539) • Part 1 is Base Language • Part 2: Varying length strings • Part 3: Conditional compilation

  28. Fortran 2000 • Exception handling • Standardized C interoperability (for OS access mainly) • Allow derived data types to have allocatable components and parameterized types (kinds) • Possibly facilities for interval arithmetic • Asynchronous and derived type I/O • Object oriented features (as long as they don't interfere with performance capabilities)

  29. Fortran 2000 Additions • Parameterized derived types: can use kinds and have allocatable entities type matrix(precision,m,n) integer, kind :: precision integer, nonkind :: m, n real(precision) :: A(m,n) end type type(matrix(kind(0.0d0), 20,20) :: G type(matrix(kind(0.0d0),:,:), allocatable :: G

  30. Fortran 2000 Additions • Procedure pointer with same interface as proc: procedure (proc), pointer : p => null( ) • Abstract interfaces to allow ptr w/o proc abstract interface real function foo(x,y) real, intent(in) :: x, y end function end interface

  31. Fortran 2000 Additions • Type-bound procedures • analogous to methods of a class • can be referenced using % operator

  32. Fortran 2000 Additions • I/O • asynchronous transfer • stream access • user specified transfer operations for derived types • user control of rounding during format conversions • named constants for preconnected units • flush statement • regularization of keywords • access to error messages

  33. C-Fortran Interoperability • Interoperability is via ISO_C_BINDING module • C_INT = int • C_SIZE_T = size_t • C_CHAR = char (but not strings) • C_PTR = void * (interoperates w/ any C ptr) • function C_LOC(x) for address finding • x = procedure, ptr to proc, variable w/ interoperable type, scalar with target attribute and already allocated

  34. C-Fortran Interoperability • Derived types must be explicitly bindable type, bind(C) :: stuff .... end type stuff • All components of type must be interoperable, not a ptr, and not allocatable • Equivalent to a corresponding C struct • Not valid: C structs with union, bit fields, flexible array components

  35. C-Fortran Interoperability • Fortran arrays interoperable with C arrays, but with reversal of subscript order • real(kind(0.0d0)) :: A(7,4:9) • double A[6][7] • In functions, can specify a dummy argument is passed by value integer, value :: x • Lets compiler do a one-way copy

  36. C-Fortran Interoperability • Make Fortran functions available by name to a C process using bind(C): • function, bind(C) :: bar(x,y) • function, bind(C,name='foo') :: bar(x,y) • Name available without underscore convention, as bar (first caes) or foo(second case)

  37. Odds and Ends • Recursive functions allowed. Specify via the recursive attribute when declared • Many F90 compilers allow • %REF( ) arguments (passes in character arrays without the implicit appending of char array length) • %VAL( ) arguments (pass by value)

  38. Conclusions • Key issues of F90 are still going to be around • Array passing, especially with slices • Dynamic library loading mechanisms • Fortran 2000 • Does not seem to introduce greatly more complexity • Does not seem to have helped much with its C-Fortran interoperability; existing conventions seem more powerful, useful • Need to analyze real F9x codes used in labs and derive support set for CCA

More Related