Fortran Data Types

!fortran example
program variables
  implicit none

  integer :: amount
  real :: pi
  complex :: frequency
  character :: initial
  logical :: isOkay
  character(len=20):: str

  amount = 10
  pi = 3.1415927
  frequency = (1.0, -0.5)
  initial = 'A'
  isOkay = .false.

  print *, amount
  print *, pi
  print *, initial
  print *, isOkay, .true.

  str = "Fortran is cool"
  print *, str
end program variables

>./vars
          10
   3.14159274    
 A
 F T
 Fortran is cool 
>       

Expressions

Expressions are sequence of identifiers, operators, separators and data literals. Each expression can produce a result of a specific data type that is determined by the compiler. You can use the expression result in a statement.

program expressions
  integer:: a = 10, b = 3
  real:: r = .0
  print *, a + 1
  print *, "a/b =", a/b
  r = (a + 2)/b
  print *, "r = ", r
  e = a ** b
  print *, "e = ", e
end program

>./exp
          11
 a/b =           3
 r =    4.00000000    
 e =    1000.00000  
>       

Notes: Expressions can be combined together to create larger expressions. In a larger expression, the order of operations is important. It is dictated by the operator priority. You can modify the order of execution using round parenthesis.

Arithmetic Expressions

In Fortran we use infix expressions. That means operator is between two operands like (x + y), therefore most operators are called binary operators. Sometimes there is only one operand, in this case the operator is "unary" operators.

Math operators

Obvious arithmetic operators are used in numeric expressions. We have a problem with the computers the number of operators is limited to the number of legacy ASCII special symbols that is very limited. We can't use Unicode symbols as operators in Fortran.

Logic expressions

Before creating conditionals you need to understand logical expressions. These are evaluated to values {.true. or .false.} in old Fortran {.T. or .F.}. You can logical and relation operators with variables, constants and function calls to create logical expressions.

Logic operators

Logic operators are based on keywords. These special keywords are enclosed between two dots. Is a little bit annoing but you can get use to it eventually.

Relation operators

Fortran operators have changed from old syntax 77 to new syntax 90 and beyond. We use these operators to create logic expressions that return a Boolean value. You can compare numbers or characters.

String expressions

In Fotran, strings are ASCII encoded. You can have string literals enclosed in single or double quoted delimiters. A delimiter must be duplicated inside string to represent the symbol itself. Usually text strings are double quoted because English has ' used in words.

Concatenation: "//"

Strings can be joined together using special operator double slash, that is usually a comment in other languages. This is why Fortran is a little bit strange. Remember, comments are starting with bang symbol "!" and this is also unusual.

!this is fortran 
program string
  implicit none

  character(len=4) :: first_name
  character(len=5) :: last_name
  character(10) :: full_name

  first_name = 'John'
  last_name = 'Smith'

  ! String concatenation
  full_name = first_name//' '//last_name

  print *, full_name

  print *, "log strings &
  can span multiple lines
  if you use operator && 
  "

end program string

Notes:

1. Numbers and strings can't be concatenated together like in JavScript or Python. You need to convert the numbers into strings before concatenation, but this is not straight forward.
2. In Fortran standard there is no escape sequence like in C. Therefore you must use function achar() to produce special characters and the you can concatenate a special character in the string.

Continuation: "&"

In Fortrand longer strings can be represented on multiple lines if each line is ending with single ampersand symbol. This is the continuation operator and is not part of the string.

program main

! escape character
character :: lf = achar(10) 

! this statement does nothing
if (.true.) continue


! long string on multiline
print "(a)", &   
  "continue " //lf//&
  "can be used "     //lf//&
  "wen a statement " //lf//&
  "is required "     //lf//&
  "but there is "    //lf//&
  "nothing to do there!"
end program

>./continue 
continue 
can be used 
wen a statement 
is required 
but there is 
nothing to do there!
>  

Notes: Symbol "&" must be used together with "//" in the example above, otherwise the strings are not concatenated and this is correct but it could have been done better.

Data Input/Output

Input/Output operations are tightly related to data types. Usually input/output can be from console or from file data fields. There are 3 statement for performing I/O.

read, write, print 

These operations require format specification, and can output a list of variables, constants or expressions. The arguments are separated by comma.

Format specification

Data format can be simple as "*" that is handled automatically by the system and it supports many variables. Better format is a string containing a set of rule that you can create for different data types. Check the example:

!fortran example
program main
  
  real:: r = 225.502
  integer:: i = 25
  character(len=*):: t= "Test"
  character(len=*),parameter::&
  fmt='(a," ", i5.4," ", f10.5)'
  
  print fmt, trim(t), i, r
end program

>./format
Test  0025  225.50200

Notes: In the example above you can see 3 variables of different kind can be combined using a single format string that has inside 3 specifications separated by comma. You will get many errors until you get the format right. The format is very powerful feature in Fortran. If you learn it right you can create a report quickly from your data.

Format Rules

Rule format is a string with the following convention: It must be enclosed in round brackets like: "( ... )" or '( ... )'. The specification can hold rules and arbitrary text. The text must be enclosed in alternative quotes, "" or '' depending on outer quotes.

Rule Multiplier

The rule can be multiplied like this: nR where n is an integer number. It will create n column having same rule R. The rule R use to start with a capital letter but new format works with lowercase letters as well.

Read next: Code Structure