- A user defined type
is defined in
Fortran 90 as follows:
TYPE TypeName type1 [,attr] :: element1; type2 [,attr] :: element2; type3 [,attr] :: element3; ... END TYPE [TypeName]Example:
TYPE myStruct INTEGER :: i; REAL :: f; END TYPE myStruct
- After defining the type
TypeName,
you can define
variables of that
type as follows:
TYPE(TypeName) :: variableName
Example:
TYPE(myStruct) :: x, A[3];
- A
user-defined type
is like a
class definition
in C++
Also, variables of a user-defined type are like class variables in C++
- You can use the variables as follows:
TYPE(TypeName) :: x x%i = the component variable "i" in "x" x = The entire object "x" (all components)
Example:
PROGRAM main IMPLICIT NONE TYPE myStruct INTEGER :: i; REAL :: f; END TYPE myStruct TYPE(myStruct) :: A, B; A%i = 4 !! Assign 4 to var i in A A%f =3.14 !! Assign 4 to var f in A B = A !! Copy both i and f from A to B END PROGRAM
- Example Program:
(Demo above code)
- Prog file: click here
- Recall that a compilation unit
in Fortran is one of:
- a Program
- a Subroutine
- a Function
- a Module
- Important:
- A type definition that appears in different compilation units is considered as a unique type
- Consider the following program:
SUBROUTINE print( x ) TYPE myStruct INTEGER :: i; REAL :: f; END TYPE myStruct TYPE(myStruct) :: x print *, "myStruct x = ", x END SUBROUTINE
PROGRAM main INTERFACE ! Declare print(x) SUBROUTINE print( x ) TYPE myStruct INTEGER :: i REAL :: f END TYPE myStruct TYPE(myStruct) :: x END SUBROUTINE END INTERFACE TYPE myStruct INTEGER :: i; REAL :: f; END TYPE myStruct TYPE(myStruct) :: A A%i = 4; A%f =3.14 CALL print(A) !! <-- Wrong type ??? ^ ERROR: The type of the actual argument, "type(MYSTRUCT)", does not match "type(MYSTRUCT)", the type of the dummy argument. END PROGRAM
- Example Program:
(Demo above code)
- Prog file: click here
- Compiler Error:
-
ERROR: The type of the actual argument,
"type(MYSTRUCT)",
does not match
"type(MYSTRUCT)",
the type of the dummy argument.
Humans will never say that, but a compiler can because it has be programmed to say that :-)...
- Compilers
can use
2 different methods
to
implement user-defined types :
- Name equivalence:
two types are equal if their names are equal.
In this kind of equivalance, one "type(MYSTRUCT)" would be equal to another "type(MYSTRUCT)")
- Index (key) equivalence:
each new type definition is assigned a unique index (or key)
In this kind of equivalance, the first "type(MYSTRUCT)" is assigned a unique index and the second "type(MYSTRUCT)" assigned a different (unique) index
Therefore, the first "type(MYSTRUCT)" does not match second "type(MYSTRUCT)"
Clearly, f90 uses index (key) equivalence
We must have one single type definition for both compile units
- Name equivalence:
two types are equal if their names are equal.
- Recall that a module
( click here)
is used to
group
a set of
related constructs, such as:
- types
- constants
- (global) variables
- declarations and
- (module) procedures
- In order satisfies
the
unique index
requirement we must
define the type once
Therefore, you must define the user-defined type in a mudule unit:
MODULE moduleName User Type Definition END MODULE
- Example:
MODULE myStructModule TYPE myStruct INTEGER :: i REAL :: f END TYPE myStruct END MODULE
- Example Program:
(Demo above code)
- Prog file: click here
- The module unit containing the
type definition
can be compiled separately using the "-c" flag:
f90 -c myStructModule.f90
After the compialtion, you will find a file mystructmodule.mod (all lower case), in your directory
- The F90 command
USE moduleName
reads in the compiled code of a module.
The types defined in the module will now be accessible to a program unit
- NOTE:
-
The
USE moduleName
command must appear as the
first statement
in a program or subroutine.
Example:
MODULE myStructModule TYPE myStruct INTEGER :: i; REAL :: f; END TYPE myStruct END MODULE
SUBROUTINE print( x ) USE myStructModule !! Defines TYPE(myStruct) IMPLICIT NONE TYPE(myStruct) :: x print *, "myStruct x = ", x END SUBROUTINE
PROGRAM main USE myStructModule !! Defines TYPE(myStruct) IMPLICIT NONE INTERFACE SUBROUTINE print( x ) USE myStructModule !! Defines TYPE(myStruct) TYPE(myStruct) :: x END TYPE myStruct END INTERFACE TYPE(myStruct) :: A A%i = 4; A%f =3.14 CALL print(A) END PROGRAM
- Example Program:
(Demo above code)
- the user-defined type module: click here
- F90 program using user-defined type:
click here
- How to compile this program:
f90 -c myStructModule.f90 f90 type02a.f90
- Recall that
variables (in non-recursive) functions in Fortran
are passed by-reference
- We just saw an example above on how to pass a user-defined type
variable....:
SUBROUTINE print( x ) USE myStructModule !! Defines TYPE(myStruct) IMPLICIT NONE TYPE(myStruct) :: x print *, "myStruct x = ", x END SUBROUTINE
PROGRAM main USE myStructModule !! Defines TYPE(myStruct) IMPLICIT NONE INTERFACE SUBROUTINE print( x ) USE myStructModule !! Defines TYPE(myStruct) TYPE(myStruct) :: x END TYPE myStruct END INTERFACE TYPE(myStruct) :: A A%i = 4; A%f =3.14 CALL print(A) END PROGRAM
- Just to show you that the user-defined type variable was
indeed
passed by reference,
here is a program that proves it:
SUBROUTINE print( x ) USE myStructModule IMPLICIT NONE TYPE(myStruct) :: x x%i = x%i + 1000 !! <--- proof of pass-by-reference x%f = x%f + 1000 END SUBROUTINE
PROGRAM main USE myStructModule IMPLICIT NONE INTERFACE SUBROUTINE print( x ) USE myStructModule TYPE(myStruct) :: x END TYPE myStruct END INTERFACE TYPE(myStruct) :: A A%i = 4; A%f =3.14 CALL print(A) print A !! <-- A changed... END PROGRAM
- Example Program:
(Demo above code)
- Prog file: click here ---
- A function that
returns
a user-defined typed variable
is defined as follows:
FUNCTION MyFuncName(Param1, Param2, ...) USE userTypeModule !! Must preceed IMPLICIT NONE IMPLICIT NONE TYPE(userType) MyFuncName .. function body END FUNCTION
Or:
FUNCTION MyFuncName(Param1, Param2, ...) RESULT(x) USE userTypeModule !! Must preceed IMPLICIT NONE IMPLICIT NONE TYPE(userType) x .. function body END FUNCTION
- Example:
MODULE complexType TYPE complexNumber REAL :: re REAL :: im END TYPE complexNumber END MODULE
FUNCTION add ( x, y ) USE complexType !! Must preceed IMPLICIT NONE IMPLICIT NONE TYPE(complexNumber) :: x, y TYPE(complexNumber) :: add ! Declare return type add%re = x%re + y%re add%im = x%im + y%im END FUNCTION
- A function that
returns
a user-defined typed variable
is declared as follows:
INTERFACE FUNCTION MyFuncName(Param1, Param2, ...) USE userTypeModule ... (declare parameters) TYPE(userType) MyFuncName END FUNCTION END INTERFACEOr:
INTERFACE FUNCTION MyFuncName(Param1, Param2, ...) RESULT(x) USE userTypeModule ... (declare parameters) TYPE(userType) x END FUNCTION END INTERFACE
- Example:
MODULE complexType TYPE complexNumber REAL :: re REAL :: im END TYPE complexNumber END MODULE
INTERFACE FUNCTION add ( x, y ) USE complexType TYPE(complexNumber) :: x, y TYPE(complexNumber) :: add ! Declare return type END FUNCTION END INTERFACE
- Example: putting the above knowledge together:
MODULE complexType TYPE complexNumber REAL :: re REAL :: im END TYPE complexNumber END MODULE
FUNCTION add ( x, y ) USE complexType !! Must preceed IMPLICIT NONE IMPLICIT NONE TYPE(complexNumber) :: x, y TYPE(complexNumber) :: add ! Declare return type add%re = x%re + y%re add%im = x%im + y%im END FUNCTION
PROGRAM main USE complexType ----------------------------+ | INTERFACE FUNCTION add ( x, y ) USE complexType --------------+ TYPE(complexNumber) :: x, y | TYPE(complexNumber) :: add <---+ END FUNCTION END INTERFACE | TYPE(complexNumber) :: a, b, c <-----------+ a%re = 3; a%im = 4 b%re = 5; b%im = -8 c = add (a, b) print *, "a = ", a print *, "b = ", b print *, "c = ", c END PROGRAM
- Example Program:
(Demo above code)
- Prog file: click here
- Module with complexType: click here
- How to compile the program:
f90 -c complexType.f90 f90 type04.f90
- Defining pointer variables of user defined type:
MODULE MyModule TYPE myType INTEGER :: i REAL :: f END TYPE END MODULE
TYPE(myType), TARGET :: A; TYPE(myType), POINTER :: ptr; ptr => A
- F90 has support for
dynamically allocated variables
using the
POINTER attribute
- Example:
MODULE MyModule TYPE myType INTEGER :: i REAL :: f END TYPE END MODULE
TYPE(myType), POINTER :: ptr; ALLOCATE(ptr) !! Dynamic variable allocation ptr%i = 4 ptr%f = 3.14
- Example Program:
(Demo above code)
- Prog file: click here
- NOTE:
- This feature allows F90 to support linked lists - which will will discuss next.
- Now you have seen
two different ways
to create
dynamical objects
- Using the ALLOCATABLE attribute
- Using the POINTER attribute
- Recall the
ALLOCATABLE attribute
was used to define
(dynamically) allocated array
REAL, DIMENSION(:), ALLOCATABLE :: A ALLOCATE(A(4)) A(1) = 1234
- Another way to have
(dynamically) allocated array
is using the
POINTER attribute:
REAL, DIMENSION(:), POINTER :: B ALLOCATE(B(4)) B(1) = 1234
- The
POINTER attribute
can be used for both
- linked data structures
(such as linked lists)
- dynamic allocation
- linked data structures
(such as linked lists)
- If
dynamic allocation alone
is needed,
it is
better
to use
ALLOCATABLE objects.
(Significant performance differences have been reported with some compilers.)
- Experiment:
(Demo above code)
- Dynamic array using ALLOCATABLE: click here
- Dynamic array using POINTER: click here
I got a few seconds in performance difference ...
- It should be easy if you understand the pass-by-reference mechanism
- Here is an example showing how to pass a structure variable
from Fortran to C:
PROGRAM main USE myStructModule IMPLICIT NONE TYPE(myStruct) :: A CALL Print_myStruct(A) !! Pass by Reference... END PROGRAM
/* Need to describe data to C ! */ struct myStruct { int i; float f; }; void print_mystruct_(struct myStruct *x) { printf("%d %f\n", x->i, x->f); } -
Example Program:
(Passing struct from F90 to C) ---
- F90 program that pass structure: click here
- C program that prints structure: click here