Operator functions in F90

Operator functions

Operator functions are functions that are invoked when the compiler encounter an expression of the following forms:

value OPERATOR value (binary operator) OPERATOR value (uniary operator)

Important restriction:

Input parameters of operator functions must be declared INTENT(IN)
I.e., operator functions cannot modify their input operands
Fortran 90 strickly enforces this requirement

(This requirement is not enforced in C++)

Defining operator function in Fortran 90

An operator function is defined as a generic function using as "named" interface
The special keyword interface is used to defined an operator function:

Syntax:

interface operator (OP_SYMBOL) one or more function declarations... end interface

Example:

interface operator (*) one or more function declarations... end interface

The * is now mapped to (one or more) ordinary F90 function(s)

F90

encounters

and

finds

matching input parameter types

, it will replace the * operator call with the corresponding function name

Example:

INTERFACE operator (*) FUNCTION f1(x, y) integer, INTENT(IN) :: x real, INTENT(IN) :: y real :: f1 END FUNCTION FUNCTION f2(y, x) integer, INTENT(IN) :: x real, INTENT(IN) :: y real :: f2 END FUNCTION END INTERFACE INTEGER i REAL r REAL x x = i * r ! F90 will invoke f1 x = r * i ! F90 will invoke f2

Example Program: (Demo above code)

Prog file: click here

Do the following:

Compile with: f90 -S operator-func01.f90

Look for the "x = i * r" and x = r * i instructions in operator-func01.s

You will see:

! 23 x = i * r ... call f1_ ! 24 x = r * i ... call f2_

Example operator function: Matrix-vector multiplication

(1) The interface definition:

interface operator (*) function MatVecMult(A,v) result (w) real, dimension(:,:), INTENT(IN) :: A real, dimension(:), INTENT(IN) :: v real, dimension(SIZE(A,1)) :: w end interface

(2) Define the function MatVecMult(A, v) (we have studied this in another webpage: click here )

function MatVecMult(A, v) result (w) implicit none real, dimension(:,:), INTENT(IN) :: A real, dimension(:), INTENT(IN) :: v real, dimension( SIZE(A,1) ) :: w integer :: i, j integer :: N N = size(v) w = 0.0 !! clear whole vector DO i = 1, N w = w + v(i) * A( :, i ) END DO end function

Complete Example:

program myProg interface operator (*) function MatVecMult(A,v) result (w) real, dimension(:,:), INTENT(IN) :: A real, dimension(:), INTENT(IN) :: v real, dimension(SIZE(A,1)) :: w end interface real, dimension( 3, 3 ) :: A real, dimension( 3 ) :: v1, v2 v2 = A * v1 end program

Example Program: (Demo above code)
- Prog file: click here

Overloading operator function

Overloading an operator function is achieved by defining multiple (distinguishable) functions in the "named" interface block

Example: overloading Matrix * Vector and Vector * Matrix

(1) The interface block:

interface operator (*) function MatVecMult(A,v) result (w) real, dimension(:,:), INTENT(IN) :: A real, dimension(:), INTENT(IN) :: v real, dimension(SIZE(A,1)) :: w function VecMatMult(v, A) result (w) real, dimension(:), INTENT(IN) :: v real, dimension(:,:), INTENT(IN) :: A real, dimension( SIZE(A,2) ) :: w end function end interface

(2) The implementation of the functions:

(1a) This function process the Matrix * Vector multiply function:
function MatVecMult(A, v) result (w) implicit none real, dimension(:,:), INTENT(IN) :: A real, dimension(:) ::, INTENT(IN) v real, dimension( SIZE(A,1) ) :: w integer :: i, j integer :: N N = size(v) w = 0.0 !! clear whole vector DO i = 1, N w = w + v(i) * A( :, i ) END DO end function

(1b) This is a Vector * Matrix multiply function:
function VecMatMult(v, A) result (w) implicit none real, dimension(:), INTENT(IN) :: v real, dimension(:,:), INTENT(IN) :: A real, dimension( SIZE(A,2) ) :: w integer :: i, N N = size(v) w = 0.0 !! clear whole vector DO i = 1, N w = w + v(i) * A( i , : ) END DO end function

Main program:

program myProg interface operator (*) function MatVecMult(A,v) result (w) !! Function 1 real, dimension(:,:), INTENT(IN) :: A real, dimension(:), INTENT(IN) :: v real, dimension(SIZE(A,1)) :: w function VecMatMult(v, A) result (w) !! Function 2 real, dimension(:), INTENT(IN) :: v real, dimension(:,:), INTENT(IN) :: A real, dimension( SIZE(A,2) ) :: w end function end interface real, dimension( 3, 3 ) :: A real, dimension( 3 ) :: v1, v2 v2 = A * v1 !! Matrix * Vector v2 = v1 * A !! Vector * Matrix

Example Program: (Demo above code)
- Prog file: click here

Caveat in operator overloading

Recall that Fortran has operators on arrays
Make sure that you do not (unintentionally) collide with an existing F90 operator

Example: Define REAL + REAL

function Add(A, B) result (C) implicit none real, INTENT(IN) :: A real, INTENT(IN) :: B real :: C C = A - B end function
program Main implicit none INTERFACE operator(+) function Add(A, B) result (C) real, INTENT(IN) :: A real, INTENT(IN) :: B real :: C end function END INTERFACE real x, y x = 3 y = 5 print *, x, y print *, "x + y", x+y end program

There can be 2 possible outcomes:

Some compilers will report an error (which is pretty obvious, you are redefining the language
(This was observed with the GNU Fortran compiler)
Other compilers actually allows you redefine the language
(This was observed with the Solaris Fortran compiler)

Example Program: (Demo above code)

Prog file: click here

Experiment:

Compile with f90 - no conflicts

SSH to crunch and compile with gfortran

Error: Operator interface at (1) conflicts with intrinsic interface

This is also the case for array operators

F90 already has an Matrix * Matrix operator:

real, dimension(3,3) :: A, B, C C = A * B "Array multiplication" Is equivalent to: DO i = 1, 3 DO j = 1, 3 C(i,j) = A(i,j) * B(i,j) END DO END DO

You can inadvertantly define the same operator with dire consequences ...

Example:

function MatMatMult(A, B) result (C) implicit none real, dimension(:,:), INTENT(IN) :: A real, dimension(:,:), INTENT(IN) :: B real, dimension( size(A,1), size(B, 2) ) :: C M = size(A,1) N = size(B,2) X = size(A,2) ! Which is also size(B(:,1)) C = 0.0 !! clear whole matrix DO i = 1, M DO j = 1, N DO k = 1, X C(i,j) = C(i,j) + A(i,k) * B(k,j) END DO END DO END DO end function
interface operator (*) function MatMatMult(A,B) result (C) !! Function 2 real, dimension(:,:), INTENT(IN) :: A real, dimension(:,:), INTENT(IN) :: B real, dimension( size(A,1), size(B, 2) ) :: C end function end interface

Example Program: (Demo above code)

Prog file: click here

Experiment:

Compile with f90 - no conflicts

SSH to crunch and compile with gfortran

Error: Operator interface at (1) conflicts with intrinsic interface

How to overload the * operator safely to perform Matrix*Matrix

To avoid colliding with Fortran's built-in operations on REAL (or double precision) number, we can define our own REAL type to distinguish our operations from those defined on the REAL type in Fortran 90

Defining our own REAL type:

MODULE MyRealModule TYPE MyReal REAL x END TYPE MyReal END MODULE MyRealModule

Define Matrix * Matrix using our own REAL type:

function MatMatMult(A, B) result (C) implicit none TYPE(MyReal), dimension(:,:), INTENT(IN) :: A TYPE(MyReal), dimension(:,:), INTENT(IN) :: B TYPE(MyReal), dimension( size(A,1), size(B, 2) ) :: C integer :: M, N, i, j M = size(A,1) N = size(B,2) C(:,:).x = 0.0 !! clear whole matrix DO i = 1, M DO j = 1, N C(:,i).x = C(:,i).x + B(j,i).x*A(:,j).x END DO END DO end function

Interface used to define the Matrix * Matrix operator:

interface operator (*) function MatMatMult(A,B) result (C) TYPE(MyReal), dimension(:,:), INTENT(IN) :: A TYPE(MyReal), dimension(:,:), INTENT(IN) :: B TYPE(MyReal), dimension( size(A,1), size(B, 2) ) :: C end function end interface

Example Program: (Demo above code)
- Prog file: click here

Defining new operators

Fortran 90 allows the programmer to define their own operator symbols (more like operator words :-) )
The new operator symbols must have the following form:

The "named" interface used to define such operator function is:

interface operator ( .OperatorName. ) .... end interface

Example: find the average of 2 REAL numbers

Interface used to define the .AVG. operator:

interface operator (.avg.) function ComputeAvg(x, y) real, INTENT(IN) :: x real, INTENT(IN) :: y real :: ComputeAvg end function end interface

Function that implements the .AVG. operator:

real function ComputeAvg(x, y) implicit none real, INTENT(IN) :: x real, INTENT(IN) :: y ComputeAvg = (x + y)/2.0 end function

Example program:

PROGRAM Main implicit none interface operator (.avg.) function ComputeAvg(x, y) real, INTENT(IN) :: x real, INTENT(IN) :: y real :: ComputeAvg end function end interface REAL a, b, c a = 4; b = 8 c = a .avg. b END PROGRAM

Example Program: (Demo above code)
- Prog file: click here

The = assignment operator

The assignment operator in F90 is a subroutine with 2 parameters

In other words:

B = A <=> "CALL operator(=) (B, A)"

As in C++, Fortran 90 provides a default assignment operator to every user defined type
Example:
And as in C++, this default assignment operator copies memory space verbatim from LHS (left hand side) to RHS (righthand side)

To define a new assignment operation , you must do this:

Define a subroutine with exactly 2 parameters
The first parameter represents the LHS variable and the second parameter represents the RHS variable

Important requirement:

The first parameter MUST be declared as INTENT(OUT) or INTENT(INOUT) (for obvious reasons)
The second parameter MUST be declared as INTENT(IN) (the reason is also obvious...)

Define a operator interface that maps the assignment operator to the subroutine

interface assignment(=) subroutine ... ... end interface

Example: assignment operator to copy F90 REAL matrix to F90 TYPE(MyReal) matrix

We want to define this operation:

REAL, DIMENSION(3,3) :: A TYPE(MyReal), DIMENSION(3,3) :: B B = A ! Illegal

Example Program: (Demo above code)
- Prog file: click here
Compile the program and you will see the error message:

To make the assignment into a legitimate operation we must define the following assignment interface

interface assignment(=) SUBROUTINE MyAssign(Y, X) use MyRealModule REAL, DIMENSION(3,3), INTENT(IN) :: X TYPE(MyReal), DIMENSION(3,3), INTENT(OUT) :: Y END SUBROUTINE end interface

Implement the MyAssign(Y, X) subroutine:

SUBROUTINE MyAssign(Y, X) use MyRealModule implicit none REAL, DIMENSION(3,3), INTENT(IN) :: X TYPE(MyReal), DIMENSION(3,3), INTENT(INOUT) :: Y Y(:,:).x = X(:,:) RETURN END SUBROUTINE

Example Program:

MODULE MyRealModule TYPE MyReal REAL x ! <---- Our own REAL type END TYPE MyReal END MODULE MyRealModule
SUBROUTINE MyAssign(Y, X) use MyRealModule implicit none REAL, DIMENSION(3,3), INTENT(IN) :: X TYPE(MyReal), DIMENSION(3,3), INTENT(INOUT) :: Y Y(:,:).x = X(:,:) RETURN END SUBROUTINE
program Main use MyRealModule implicit none integer i REAL, DIMENSION(3,3) :: A TYPE(MyReal), DIMENSION(3,3) :: B interface assignment(=) SUBROUTINE MyAssign(Y, X) use MyRealModule REAL, DIMENSION(3,3), INTENT(IN) :: X TYPE(MyReal), DIMENSION(3,3), INTENT(INOUT) :: Y END SUBROUTINE end interface B = A end program

Example Program: (Demo above code)
- Prog file: click here

Epilogue:

I have only defined a TYPE(MyReal) = REAL assignment operator for matrices (2-dimensional arrays).
It will not work if you want to assign REAL vectors to TYPE(MyReal) vectors (1-dimensional array).
To make assignment work for vectors also, you must write another subroutine and overload the assignment operator and this subroutine must use 1-dimensional array as input parameter (using the same technique that was discussed here: click here )