Advanced Fortran 90

---

Introduction

• Personal Introduction
• The mind of the language writers
• Justification for topics covered
• Classification of topics covered
• Listing of covered topics
• Format of our talk
• Meat

---

Who am I?

• Physics
• Electrical Engineering
• Computer Science

• Defense Industry
• Academia

• Fortran
• C
• C++
• Pascal
• Lisp
• Java
• Others

The mind of the language writers

• Same precision
• Include many common extensions

• Writing
• Maintaining
• Understanding
• Reading

Why Fortran?

---

Justification of topics

• Enhance performance
• Enhance portability
• Enhance reliability
• Enhance maintainability

---

Classification of topics

• New useful features
• Old tricks
• Power features

---

Listing of topics covered

1. Listing of topics covered
2. Format for our talk
3. What is a Genetic Algorithm
4. Simple algorithm for a GA
5. Our example problem
6. Start of real Fortran 90 discussion
7. Comparing a FORTRAN 77 routine to a Fortran 90 routine
8. Obsolescent features
9. New source Form (and related things)
10. New data declaration method
11. Kind facility
12. Modules
13. Module functions and subroutines
14. Allocatable arrays (the basics)
15. Passing arrays to subroutines
16. Interface for passing arrays
17. Optional arguments and intent
18. Derived data types
19. Using defined types
20. User defined operators
21. Recursive functions introduction
22. Fortran 90 recursive functions
23. Pointers
24. Function and subroutine overloading
25. Fortran Minval and Minloc routines
26. Pointer assignment
27. More pointer usage, association and nullify
28. Pointer usage to reference an array
29. Data assignment with structures
30. Using the user defined operator
31. Passing arrays with a given arbitrary lower bounds
32. Using pointers to access sections of arrays
33. Allocating an array inside a subroutine
34. Our fitness function
35. Linked lists
36. Linked list usage
37. Our map representation
38. Non advancing and character I/O
39. Date and time functions
40. Internal I/O
41. Inquire function
42. Namelist
43. Vector valued functions
44. Complete source for recent discussions
45. Some array specific intrinsic functions
46. The rest of our GA
47. Compiler Information
48. Fortan 95
49. Summary
50. References

---

Format for our talk

• We will "develop" an application
• Incorporate f90 features
• Show source code
• Explain what and why as we do it
• Important parts of source code are in red    (If I don't talk about it, ask!)
• Application is a genetic algorithm
• Easy to understand and program
• Offers rich opportunities for enhancement

---

What is a Genetic Algorithm

• Find good, but maybe not optimal, solutions to difficult problems
• Often used on NP-Hard or combinatorial optimization problems

• Solution(s) to the problem represented as a string
• A fitness function
• Takes as input the solution string
• Output the desirability of the solution
• A method of combining solution strings to generate new solutions

---

Simple algorithm for a GA

• evaluate each individual (string) of the population using the fitness function
• sort the population with fittest coming to the top
• allow the fittest individuals to "sexually" reproduce replacing the old population
• allow for mutation

Our example problem

• Given a map of the N  states or countries and a fixed number of colors
• Find a coloring of the map, if it exists, such that no two states that share a boarder have the same color

• In general, for a fixed number of colors and an arbitrary map the only known way to find if there is a valid coloring is a brute force search with the number of combinations = (NUMBER_OF_COLORS)**(NSTATES)
• The strings of our population are integer vectors represent the coloring
• Our fitness function returns the number of boarder violations
• The GA searches for a mapping with few, hopefully 0 violations
• This problem is related to several important NP_HARD problems in computer science
• Processor scheduling
• Communication and grid allocation for parallel computing
• Routing

A preview:  Comparing a FORTRAN 77 routine to a Fortran 90 routine

• correct bugs
• increase functionality
• aid portability

Obsolescent features

---

New source form (and related things)

• Summary
• ! now indicates the start of a comment
• & indicates the next line is a continuation
• Lines can be longer than 72 characters
• Statements can start in any column
• Use ; to put multiple statements on one line
• New forms for the do loop
• Many functions are generic
• 32 character names
• Many new array assignment techniques

• Features
• Flexibility can aid in program readability
• Readability decreases errors

• Got ya!
• Can no longer use C to start a comment
• Character in column 5 no longer is continue
• Tab is not a valid character (may produce a warning)
• Characters past 72 now count

New data declaration method

• Variables can now have attributes such as
• Parameter
• Save
• Dimension
•  Attributes are assigned in the variable declaration statement

• allocatable
• public
• private
• target
• pointer
• intent
• optional

 
 

---

Kind facility

• Assume we have a program that we want to run on two different machines
• We want the same representation of reals on both machines  (same number of significant digits)
• Problem: different machines have different representations for reals

• We may want to run with at least 6 digits today and at least 14 digits tomorrow
• Use the Select_Real_Kind(P) function to create a data type with P digits of precision

sp001 % cat darwin.f
program darwin
! e has at least 4 significant digits
  real(selected_real_kind(4))e
! b8 will be used to define reals with 14 digits
  integer, parameter:: b8 = selected_real_kind(14)
  real(b8), parameter :: pi = 3.141592653589793239_b8 ! note usage of _b8
                                                      ! with  a constant
                                                      ! to force precision
 e= 2.71828182845904523536
  write(*,*)"starting ",&  ! this line is continued by using "&"
            "darwin"       ! this line in a continuation from above
  write(*,*)"pi has ",precision(pi)," digits precision ",pi
  write(*,*)"e has   ",precision(e)," digits precision ",e
end program

  % darwin
 starting darwin
 pi has  15  digits precision  3.14159265358979312
 e has    6  digits precision  2.718281746
sp001 %
 

• Can convert to/from given precision for all variables created using "b8" by changing definition of "b8"
• Use the Select_Real_Kind(P,R) function to create a data type with P digits of precision and exponent range of R

---

Modules

• Common block usage is prone to error
• Provide most of capability of common blocks but safer
• Provide capabilities beyond common blocks

• Data definitions
• Data to be shared much like using a labeled common
• Functions and subroutines
• Interfaces (more on this later)

module numz
  integer, parameter:: b8 = selected_real_kind(14)
  real(b8), parameter :: pi = 3.141592653589793239_b8
  integer gene_size
end module

program darwin
  use numz
  implicit none   ! now part of the standard, put it after the use statements
  write(*,*)"pi has ",precision(pi)," digits precision ",pi
  call set_size()
  write(*,*)"gene_size=",gene_size
end program

subroutine set_size
  use numz
  gene_size=10
end subroutine set_size
 

 pi has  15  digits precision  3.14159265358979312
 gene_size= 10

Module functions and subroutines

• Encapsulate related functions and subroutines
• Can "USE" these functions in a program or subroutine
• Can be provided as a library
• Only routines that contain the use statement can see the routines

module ran_mod
! module contains three functions
! ran1 returns a uniform random number between 0-1
! spread returns random number between min - max
! normal returns a normal distribution

contains
    function ran1()  !returns random number between 0 - 1
        use numz
        implicit none
        real(b8) ran1,x
        call random_number(x) ! built in fortran 90 random number function
        ran1=x
    end function ran1

    function spread(min,max)  !returns random number between min - max
        use numz
        implicit none
        real(b8) spread
        real(b8) min,max
        spread=(max - min) * ran1() + min
    end function spread

    function normal(mean,sigma) !returns a normal distribution
        use numz
        implicit none
        real(b8) normal,tmp
        real(b8) mean,sigma
        integer flag
        real(b8) fac,gsave,rsq,r1,r2
        save flag,gsave
        data flag /0/
        if (flag.eq.0) then
        rsq=2.0_b8
            do while(rsq.ge.1.0_b8.or.rsq.eq.0.0_b8) ! new from for do
                r1=2.0_b8*ran1()-1.0_b8
                r2=2.0_b8*ran1()-1.0_b8
                rsq=r1*r1+r2*r2
            enddo
            fac=sqrt(-2.0_b8*log(rsq)/rsq)
            gsave=r1*fac
            tmp=r2*fac
            flag=1
        else
            tmp=gsave
            flag=0
        endif
        normal=tmp*sigma+mean
        return
    end function normal

end module ran_mod
 

Allocatable arrays (the basics)

• At compile time we may not know the size an array need to be

• We may want to change problem size without recompiling

program darwin
    use numz
    implicit none
    integer ierr
    call set_size()
    allocate(a_gene(gene_size),stat=ierr) !stat= allows for an error code return
    if(ierr /= 0)write(*,*)"allocation error"  ! /= is .ne.
    allocate(many_genes(gene_size,num_genes),stat=ierr)  !2d array
    if(ierr /= 0)write(*,*)"allocation error"
    write(*,*)lbound(a_gene),ubound(a_gene) ! get lower and upper bound
                                            ! for the array
    write(*,*)size(many_genes),size(many_genes,1) !get total size and size
                                                  !along 1st dimension
    deallocate(many_genes) ! free the space for the array and matrix
    deallocate(a_gene)
    allocate(a_gene(0:gene_size)) ! now allocate starting at 0 instead of 1
    write(*,*)allocated(many_genes),allocated(a_gene) ! shows if allocated
    write(*,*)lbound(a_gene),ubound(a_gene)
end program
 

subroutine set_size
    use numz
    write(*,*)'enter gene size:'
    read(*,*)gene_size
    write(*,*)'enter number of genes:'
    read(*,*)num_genes
end subroutine set_size
 

  enter gene size:
10
 enter number of genes:
20
           1          10
         200          10
 F T
           0          10
  

Passing arrays to subroutines

• Explicit shape
•     integer, dimension(8,8)::an_explicit_shape_array
• Assumed size
•     integer, dimension(i,*)::an_assumed_size_array
• Assumed Shape
•     integer, dimension(:,:)::an_assumed_shape_array

subroutine arrays(an_explicit_shape_array,&
                  i                      ,& !note we pass all bounds except the last
                  an_assumed_size_array  ,&
                  an_assumed_shape_array)
! Explicit shape
    integer, dimension(8,8)::an_explicit_shape_array
! Assumed size
    integer, dimension(i,*)::an_assumed_size_array
! Assumed Shape
    integer, dimension(:,:)::an_assumed_shape_array
    write(*,*)sum(an_explicit_shape_array)
    write(*,*)lbound(an_assumed_size_array) ! why does sum not work here?
    write(*,*)sum(an_assumed_shape_array)
end subroutine
 

Interface for passing arrays

• Similar to C prototypes but much more versatile
• The interface is a copy of the invocation line and the argument definitions
• Modules are a good place for interfaces
• If a procedure is part of a "contains" section in a module an interface is not required

module numz
    integer, parameter:: b8 = selected_real_kind(14)
    integer,allocatable :: a_gene(:),many_genes(:,:)
end module

module face
    interface fitness
        function fitness(vector)
        use numz
        implicit none
        real(b8) fitness
        integer, dimension(:) ::  vector
        end function fitness
    end interface
end module

program darwin
    use numz
    use face
    implicit none
    integer i
    integer vect(10) ! just a regular array
    allocate(a_gene(10));allocate(many_genes(3,10))
    a_gene=1  !sets every element of a_gene to 1
    write(*,*)fitness(a_gene)
    vect=8
    write(*,*)fitness(vect) ! also works with regular arrays
    many_genes=3  !sets every element to 3
    many_genes(1,:)=a_gene  !sets column 1 to a_gene
    many_genes(2,:)=2*many_genes(1,:)
    do i=1,3
        write(*,*)fitness(many_genes(i,:))
    enddo
    write(*,*)fitness(many_genes(:,1))  !go along other dimension
!!!!write(*,*)fitness(many_genes)!!!!does not work
end program

function fitness(vector)
    use numz
    implicit none
    real(b8) fitness
    integer, dimension(:)::  vector ! must match interface
    fitness=sum(vector)
end function

Optional arguments and intent

• We may have a function or subroutine that we may not want to always pass all arguments
• Initialization

Seeding the intrinsic random number generator requires keyword arguments

• To define an optional argument in our own function we use the optional attribute

    integer :: my_seed
        becomes
  integer, optional :: my_seed

program darwin
    use numz
    use ran_mod          ! interface required if we have
                         ! optional or intent arguments
    real(b8) x,y
    x=ran1(my_seed=12345) ! we can specify the name of the argument
    y=ran1()
    write(*,*)x,y
    x=ran1(12345)         ! with only one optional argument we don't need to
    y=ran1()
    write(*,*)x,y
end program
 

• intent(in)
• We will not change this value in our subroutine
• intent(out)
• We will define this value in our routine
• intent(inout)
• The normal situation

Derived data types

• Derived data types can be used to group different types of data together (integers, reals, character, complex)
• Can not be done in F77 although people have "faked" it

• In our GA we define a collection of genes as a 2d array
• We call the fitness function for every member of the collection
• We want to sort the collection of genes based on result of fitness function
• Define a data type that holds the fitness value and an index into the 2d array
• Create an array of this data type, 1 for each member of the collection
• Call fitness function with the result being placed into the new data type along with a pointer into the array

module galapagos
    use numz
    type thefit !the name of the type
      sequence  ! sequence forces the data elements
                ! to be next to each other in memory
                ! where might this be useful?
      real(b8) val   ! our result from the fitness function
      integer index  ! the index into our collection of genes
    end type thefit
end module

Using defined types

program darwin
    use numz
    use galapagos ! the module that contains the type definition
    use face      ! contains various interfaces
 implicit none
! define an allocatable array of the data type
! than contains an index and a real value
    type (thefit),allocatable ,target :: results(:)
! create a single instance of the data type
    type (thefit) best
    integer,allocatable :: genes(:,:) ! our genes for the genetic algorithm
    integer j
    integer num_genes,gene_size
    num_genes=10
    gene_size=10
    allocate(results(num_genes))         ! allocate the data type
                                         ! to hold fitness and index
    allocate(genes(num_genes,gene_size)) ! allocate our collection of genes
    call init_genes(genes)               ! starting data
    write(*,'("input")') ! we can put format in write statement
    do j=1,num_genes
       results(j)%index=j
       results(j)%val=fitness(genes(j,:)) ! just a dummy routine for now
       write(*,"(f10.8,i4)")results(j)%val,results(j)%index
    enddo
end program
 

---

User defined operators

• With derived data types we may want (need) to define operations
• (Assignment is predefined)

• <, >, ==  not defined for our data types
• We want to find the minimum of our fitness values so we need < operator
• In our sort routine we want to do <, >, ==
• In C++ terms the operators are overloaded
• We are free to define new operators

• Define a special interface
• Define the function that performs the operation

  interface operator (.gt.)   ! overloads standard .gt.
    module procedure thegreat ! the function that does it
  end interface

  interface operator (.ge.)  ! overloads standard .ge.
    module procedure thetest ! the function that does it
  end interface

  interface operator (.converged.)  ! new operator
    module procedure index_test     ! the function that does it
  end interface

contains      ! our module will contain
              ! the required functions
 

  function theless(a,b) ! overloads < for the type (thefit)
    use galapagos
    implicit none
    type(thefit), intent (in) :: a,b
    logical theless           ! what we return
    if(a%val < b%val)then     ! this is where we do the test
        theless=.true.
    else
        theless=.false.
    endif
    return
  end function theless

  function thegreat(a,b) ! overloads > for the type (thefit)
    use galapagos
    implicit none
    type(thefit), intent (in) :: a,b
    logical thegreat
    if(a%val > b%val)then
        thegreat=.true.
    else
        thegreat=.false.
    endif
    return
  end function thegreat
 

function thetest(a,b)   ! overloads >= for the type (thefit)
    use galapagos
    implicit none
    type(thefit), intent (in) :: a,b
    logical thetest
    if(a%val >= b%val)then
        thetest=.true.
    else
        thetest=.false.
    endif
    return
end function thetest
 

function index_test(a,b) ! defines a new operation for the type (thefit)
    use galapagos
    implicit none
    type(thefit), intent (in) :: a,b
    logical index_test
    if(a%index > b%index)then   ! check the index value for a difference
        index_test=.true.
    else
        index_test=.false.
    endif
    return
end function index_test

Recursive functions introduction

• Recursive function is one that calls itself
• Anything that can be done with a do loop can be done using a recursive function

• Sometimes it is easier to think recursively
• Divide an conquer algorithms are recursive by nature
• Fast FFTs
• Searching
• Sorting

Fortran 90 recursive functions

recursive function realmin(ain) result (themin)
! recursive and result are required for recursive functions
    use numz
    implicit none
    real(b8) themin,t1,t2
    integer n,right
    real(b8) ,dimension(:) :: ain
    n=size(ain)
    if(n == 1)then
       themin=ain(1) ! if the size is 1 return value
    return
    else
      right=n/2
      t1=realmin(ain(1:right))   ! find min in left half
      t2=realmin(ain(right+1:n)) ! find min in right half
      themin=min(t1,t2)          ! find min of the two sides
     endif
end function
 

Pointers

• Can increase performance
• Can improve readability
• Required for some derived data types (linked lists and trees)
• Useful for allocating "arrays" within subroutines
• Useful for referencing sections of arrays

• Pointers can be thought of as an alias to another variable
• In some cases can be used in place of an array
• To assign a pointer use => instead of just =
• Unlike C and C++, pointer arithmetic is not allowed

• Similar to the last findmin routine
• Return a pointer to the minimum

Function and subroutine overloading

• Allows us to call functions or subroutine with the same name with different argument types
• Increases readability

• Similar in concept to operator overloading
• Requires an interface
• Syntax for subroutines is same as for functions
• Many intrinsic functions have this capability
• abs (reals,complex,integer)
• sin,cos,tan,exp(reals, complex)
• array functions(reals, complex,integer)

• Recall we had two functions that did the same thing but with different argument types

        recursive function realmin(ain) result (themin)
        real(b8) ,dimension(:) :: ain

        recursive function typemin(ain) result (themin)
        type (thefit) ,dimension(:) :: ain
 

•  We can define a generic interface for these two functions and call them using the same name

! note we have two functions within the same interface
! this is how we indicate function overloading
! both functions are called "findmin" in the main program
interface findmin

!
! the first is called with an array of reals as input
        recursive function realmin(ain) result (themin)
          use numz
       real(b8) themin
          real(b8) ,dimension(:) :: ain
        end function

! the second is called with a array of data structures as input
     recursive function typemin(ain) result (themin)
          use numz
    use galapagos
       real(b8) themin
          type (thefit) ,dimension(:) :: ain
     end function
    end interface
 
 

    allocate(z(size(results)))
    z=results(:)%val ! copy our results to a real array

! use a recursive subroutine operating on the real array
    write(*,*)"the lowest fitness: ",findmin(z)
! use a recursive subroutine operating on the data structure
    write(*,*)"the lowest fitness: ",findmin(results)

Fortran Minval and Minloc routines

• minval
• maxval
• minloc (returns an array)
• maxloc (returns an array)

 Pointer assignment

• worst is a pointer to our data type
• note the use of =>

More pointer usage, association and nullify

• Need to find if pointers point to anything
• Need to find if two pointers point to the same thing
• Need to deallocate and nullify when they are no longer used

• We can use associated() to tell if a pointer has been set
• We can use associated() to compare pointers
• We use nullify to zero a pointer

! This code will print "true" when we find a match,
! that is the pointers point to the same object
    do j=1,num_genes
     tmp=>results(j)
        write(*,"(f10.8,i4,l3)")results(j)%val,   &
                                results(j)%index, &
           associated(tmp,worst)
    enddo
    nullify(tmp)
 

• If a pointer is nullified the object to which it points is not deallocated.
• In general, pointers as well as allocatable arrays become undefined on leaving a subroutine
• This can cause a  memory leak

Pointer usage to reference an array without copying

• Our sort routine calls a recursive sorting routine
• It is messy and inefficient to pass the array to the recursive routine

• We define a "global" pointer in a module
• We point the pointer to our input array

subroutine Sort(ain, n)
    use Merge_mod_types
    implicit none
    integer n
    type(thefit), target:: ain(n)
    allocate(work(n))
    nullify(a_pntr)
    a_pntr=>ain  ! we assign the pointer to our array
                 ! in RecMergeSort we reference it just like an array
    call RecMergeSort(1,n) ! very similar to the findmin functions
    deallocate(work)
    return
end subroutine Sort
 

! our sort routine is also recursive but
! also shows a new usage for pointers
    call sort(results,num_genes)
    do j=1,num_genes
       write(*,"(f10.8,i4)")results(j)%val,   &
                            results(j)%index
    enddo

Data assignment with structures

Using the user defined operator

! using the user defined operator to see if best is worst
! recall that the operator .converged. checks to see if %index matches
    worst=>pntmin(results)
    write(*,*)"worst result ",worst
    write(*,*)"converged=",(best .converged. worst)

Passing arrays with a given arbitrary lower bounds

• Default lower bound within a subroutine is 1
• May want to use a different lower bound

! pass z and its lower bound
! in this routine we give the array a specific lower
! bound and show how to use a pointer to reference
! different parts of an array using different indices
  call boink1(z,lbound(z,1)) ! why not just lbound(z) instead of lbound(z,1)?
                             ! lbound(z) returns a rank 1 array
 

   subroutine boink1(a,n)
     use numz
     implicit none
     integer,intent(in) :: n
     real(b8),dimension(n:):: a ! this is how we set lower bounds in a subroutine
     write(*,*)lbound(a),ubound(a)
   end subroutine
 
Warning:  because we are using an assumed shape array we need an interface

Using pointers to access sections of arrays

• Can increase efficiency
• Can increase readability

subroutine boink2(a,n)
 use numz
 implicit none
 integer,intent(in) :: n
 real(b8),dimension(n:),target:: a
 real(b8),dimension(:),pointer::b
     b=>a(n:) ! b(1) "points" to a(-10)
     write(*,*)"a(-10) =",a(-10),"b(1) =",b(1)
     b=>a(0:) ! b(1) "points" to a(0)
     write(*,*)"a(-6) =",a(-6),"b(-5) =",b(-5)
end subroutine

Allocating an array inside a subroutine and passing it back

• Size of arrays are calculated in the subroutine

module numz 
    integer, parameter:: b8 = selected_real_kind(14)
end module

program bla
   use numz
   real(b8), dimension(:) ,pointer :: xyz 

   interface boink 
     subroutine boink(a) 
     use numz
     implicit none 
     real(b8), dimension(:), pointer :: a 
     end subroutine 
   end interface 

   
   nullify(xyz) ! nullify sets a pointer to null 
   write(*,'(l5)')associated(xyz) ! is a pointer null, should be 
   call boink(xyz) 
   write(*,'(l5)',advance="no")associated(xyz) 
   if(associated(xyz))write(*,'(i5)')size(xyz) 
end program  

subroutine boink(a) 
    use numz 
    implicit none 
    real(b8),dimension(:),pointer:: a 
    if(associated(a))deallocate(a) 
    allocate(a(10)) 
end subroutine 

     F
     T     10

Our fitness function

Example input is a sorted list of 22 western states
22
ar ok tx la mo xx
az ca nm ut nv xx
ca az nv or xx
co nm ut wy ne ks xx
ia mo ne sd mn xx
id wa or nv ut wy mt xx
ks ne co ok mo xx
la tx ar xx
mn ia sd nd xx
mo ar ok ks ne ia xx
mt wy id nd xx
nd mt sd wy xx
ne sd wy co ks mo ia xx
nm az co ok tx mn xx
nv ca or id ut az xx
ok ks nm tx ar mo xx
or ca wa id xx
sd nd wy ne ia mn xx
tx ok nm la ar xx
ut nv az co wy id xx
wa id or mt xx
wy co mt id ut nd sd ne xx

Our fitness function takes a potential coloring, that is, an integer vector of length N and a returns the number of boarders that have states of the same coloring
 

• One way would be to use an array but it would be very sparse
• Linked lists are often a better way

Linked lists

• We have a collection of states and for each state a list of adjoining states. (Do not count a boarder twice.)
• Problem is that you do not know the length of the list until runtime.
• List of adjoining states will be different lengths for different states

• Linked list are a good way to handle such situations
• Linked lists use a derived data type with at least two components
• Data
• Pointer to next element

module list_stuff
    type llist
        integer index                ! data
        type(llist),pointer::next    ! pointer to the
                                     ! next element
    end type llist
end module

Linked list usage

Our map representation

• State is name of a state
• Linked list containing boarders

    type states
        character(len=2)name
        type(llist),pointer :: list
    end type states

• We have an array of linked lists
• This data structure is often used to represent sparse arrays
• We could have a linked list of linked lists
• State name is not really required

---

Non advancing and character I/O

• We read the states using the two character identification
• One line per state and do not know how many boarder states per line

Date and time functions

• May want to know the date and time of your program
• Two functions

Internal I/O

• May need to create strings on the fly
• May need to convert from strings to reals and integers
• Similar to sprintf and sscanf

• Create a string
• Do a normal write except write to the string instead of file number

     character (len=12)tmpstr
 
     write(tmpstr,"(a12)")(c_date(5:8)//c_time(1:4)//".dat") ! // does string concatination
     write(*,*)"name of file= ",tmpstr
     open(14,file=tmpstr)

     name of file= 03271114.dat

     format= (   9i1,1x,f10.5)

Any other ideas for writing an array when you do not know its length?
 

Inquire function

• Need to get information about I/O

• Information about files (23 different requests can be done)
• Information about space required for binary output of a value

• Useful for inter language programming
• Useful for determining data types in MPI (MPI_REAL or MPI_DOUBLE_PRECISION)

 len_b8             2
 len_real           1

Namelist

• A convenient method of doing I/O
• Good for cases where you have similar runs but change one or two variables
• Good for formatted output

• A little flaky
• No options for overloading format

&THE_INPUT NCOLOR=4,FORCE   = F /
 

 &THE_INPUT
 NCOLOR  =           4,
 FORCE   = F
 /
 

---

Vector valued functions

• May want a function that returns a vector

• Again requires an interface
• Use explicit or assumed size array
• Do not return a pointer to a vector unless you really want a pointer

• Take an integer input vector which represents an integer in some base and add 1
• Could be used in our program to find a "brute force" solution

Usage

        test_vect=0
        do
           test_vect=add1(test_vect,3)
           result=fitness(test_vect)
           if(result < 1.0_b8)then
               write(*,*)test_vect
               stop
           endif
        enddo
 

Complete source for recent discussions

Some array specific intrinsic functions

 program matrix
       real w(10),x(10),mat(10,10)
       call random_number(w)
       call random_number(mat)
       x=matmul(w,mat)   ! regular matrix multiply  USE IT
      write(*,'("dot(x,x)=",f10.5)'),dot_product(x,x)
end program

 program allit
     character(len=10):: f1="(3l1)"
     character(len=10):: f2="(3i2)"
     integer b(2,3),c(2,3),one_d(6)
     logical l(2,3)
     one_d=(/ 1,3,5 , 2,4,6 /)
     b=transpose(reshape((/ 1,3,5 , 2,4,6 /),shape=(/3,2/)))
     C=transpose(reshape((/ 0,3,5 , 7,4,8 /),shape=(/3,2/)))
     l=(b.ne.c)
     write(*,f2)((b(i,j),j=1,3),i=1,2)
     write(*,*)
     write(*,f2)((c(i,j),j=1,3),i=1,2)
     write(*,*)
     write(*,f1)((l(i,j),j=1,3),i=1,2)
     write(*,*)
     write(*,f1)all ( b .ne. C ) !is .false.
     write(*,f1)all ( b .ne. C, DIM=1) !is [.true., .false., .false.]
     write(*,f1)all ( b .ne. C, DIM=2) !is [.false., .false.]
end
 

The rest of our GA

• Reproduction
• Mutation

Compiler Information

• f90

• suffix       *.f90
• -64          create 64 bit programs (required on these machines)
• man page is not up to date
• found bugs in the compiler related to optional arguments

 

• f90
• suffix    *.f   *.f90
• -r3        massive source listing (There are many options for listings)
• -f free
• -f fixed   The default is fixed for input files that end with a .f  The
•            default is free for input files that end  with a .f90 suffix.
• -O3        Highest general optimization
• -Otask3    Multitasking optimization
• -Ovector3  Highest vector optimization
• Debugger   totalview
• Profile    ja
• Optimizer  xbrowse, perfview, jumpview

• f90
• suffix    *.f   *.f90
• -r3        massive source listing (There are many options for listings)
• -f free
• -f fixed   The default is fixed for input files that end with a .f  The
•            default is free for input files that end  with a .f90 suffix.
• -O3        Highest general optimization
• Debugger   totalview
• Optimizer  apprentice, pat

• xlf90

• suffix       *.f
• -O3          Highest level optimization with fast runtime but slow compile
• -qfixed      Source is in fixed format
• -qfree       Source is in free format (the default)
• -qsource     Produce a source listing
• -qarch=pwrx  Sets processor type pwrx, 604, 601
• Debugger     xldb

Fortran 95

The statement FORALL as an alternative to the DO-statement

Partial nesting of FORALL and WHERE statements

Masked ELSEWHERE

Pure procedures

Elemental procedures

Pure procedures in specification expressions

Revised MINLOC and MAXLOC

Extensions to CEILING and FLOOR with the KIND keyword argument

Pointer initialization

Default initialization of derived type objects

Increased compatibility with IEEE arithmetic

A CPU_TIME intrinsic subroutine

A function NULL to nullify a pointer

Automatic deallocation of allocatable arrays at exit of scoping unit

Comments in NAMELIST at input

Minimal field at input

Complete version of END INTERFACE

real and double precision DO loop index variables

branching to END IF from an outer block

PAUSE statements

ASSIGN statements and assigned GO TO statements and the use of an assigned integer as a FORMAT specification

Hollerith editing in FORMAT

Summary

• Enhance performance
• Enhance portability
• Enhance reliability
• Enhance maintainability

• Source form
• Derived data types
• Dynamic memory allocation functions
• Kind facility for portability and easy modification
• Many new intrinsic function
• Array assignments

• Help show how things work
• Reference for future use

References