# Functions Examples

Here are a few examples of functions:

• The following function has a name Sum and three formal arguments a, b and c. It returns an INTEGER function value. The INTEGER, INTENT(IN) part indicates that the function takes its input value from its three formal argument. Then, the function uses the value of these formal arguments to compute the sum and stores in Sum, the name of the function. Since the next statement is END FUNCTION, the function returns the value stored in Sum.
```INTEGER FUNCTION  Sum(a, b, c)
IMPLICIT  NONE

INTEGER, INTENT(IN) :: a, b, c

Sum = a + b + c
END FUNCTION  Sum
```
If the value supplied to a, b and c are 3, 5, and -2, respectively, Sum will receive 6 (=3+5+(-2)) and the function returns 6.
• The following function has a name Positive with a REAL formal argument. If the argument is positive, the function returns .TRUE.; otherwise, the function returns .FALSE.
```LOGICAL FUNCTION  Positive(a)
IMPLICIT  NONE

REAL, INTENT(IN) :: a

IF (a > 0.0)  THEN
Positive = .TRUE.
ELSE
Positive = .FALSE.
END IF
END FUNCTION  Positive
```
The above function can be made much shorter by using LOGICAL assignment. In the following, if a > 0.0 is true, .TRUE. is stored to Positive; otherwise, Positive receives .FALSE.
```LOGICAL FUNCTION  Positive(a)
IMPLICIT  NONE

REAL, INTENT(IN) :: a

Positive = a > 0.0
END FUNCTION  Positive
```
• The following function, LargerRoot, takes three REAL formal arguments and returns a REAL function value. It returns the larger root of a quadratic equation ax2 + bx + c = 0.
```REAL FUNCTION  LargerRoot(a, b, c)
IMPLICIT  NONE

REAL, INTENT(IN) :: a
REAL, INTENT(IN) :: b
REAL, INTENT(IN) :: c
REAL             :: d, r1, r2

d  = SQRT(b*b - 4.0*a*c)
r1 = (-b + d) / (2.0*a)
r2 = (-b - d) / (2.0*a)
IF (r1 >= r2) THEN
LargerRoot = r1
ELSE
LargerRoot = r2
END IF
END FUNCTION  LargerRoot
```
The above example shows that you can declare other variables such as d, r1 and r2 if they are needed.
• The following function, Factorial(), has only one INTEGER formal argument n >= 0, and computes and returns the factorial of n, n!.
```INTEGER FUNCTION  Factorial(n)
IMPLICIT  NONE

INTEGER, INTENT(IN) :: n
INTEGER             :: i, Ans

Ans = 1
DO i = 1, n
Ans = Ans * i
END DO
Factorial = Ans
END FUNCTION
```
Note that the function name Factorial is not used in any computation. Instead, a new INTEGER variable is used for computing n!. The final value of Ans is stored to Factorial before leaving the function.

If Factorial is involved in computation like the following:

```INTEGER FUNCTION  Factorial(n)
IMPLICIT  NONE

INTEGER, INTENT(IN) :: n
INTEGER             :: i

Factorial = 1
DO i = 1, n
Factorial = Factorial * i
END DO
END FUNCTION
```
then there is a mistake although the above program looks normal. The reason is that the function name cannot appear in the right-hand side in any expression of that function.
• The following function GetNumber() does not have any formal arguments and returns an INTEGER function value. This function has a DO-loop which keeps asking the user to input a positive number. The input is read into the function name. If this value is positive, then EXIT and the function returns the value in GetNumber. Otherwise, the loop goes back and asks the user again for a new input value.
```REAL FUNCTION  GetNumber()
IMPLICIT  NONE

DO
WRITE(*,*)  'A positive real number --> '