Educational

Functions with Multiple Arguments in Fortran

—

by

Saim Khalid
in

In Fortran programming, functions are essential for modular, reusable, and organized code. Functions can accept one or more arguments (parameters), process them, and return a result. Using functions with multiple arguments allows programmers to perform calculations or transformations involving several inputs without repeating code. This post provides a detailed explanation of functions with multiple arguments in Fortran, including syntax, examples, and practical applications.

1. Introduction to Functions

A function is a subprogram that:

  • Accepts inputs (called arguments or parameters)
  • Performs a computation or operation
  • Returns a single result

Functions improve code readability, maintainability, and reusability.

In Fortran, the general structure of a function is:

function function_name(arg1, arg2, ..., argN)

! declarations
function_type :: function_name
! arguments declaration
function_name = result
end function function_name

2. Functions with Multiple Arguments

When a function requires more than one input, multiple arguments are declared in the function signature and given types using intent(in).

  • intent(in) indicates that the argument is read-only within the function.
  • The function can perform computations using all arguments and return a single value.

Syntax Example

function my_function(a, b, c)

real :: my_function
real, intent(in) :: a, b, c
my_function = a * b + c
end function my_function
  • a, b, and c are inputs.
  • The function calculates a * b + c and returns the result.

3. Calling Functions with Multiple Arguments

To use the function, assign its return value to a variable:

real :: result
result = my_function(2.0, 3.0, 4.0)
print *, "Result:", result

Explanation:

  • my_function(2.0, 3.0, 4.0) passes three arguments.
  • The function multiplies 2.0 and 3.0, then adds 4.0, returning 10.0.
  • Output:
Result: 10.0

4. Example: Multiply and Add Function

Here is a complete example with multiple arguments:

program test_function

real :: result
result = multiply_add(2.0, 3.0, 4.0)
print *, "Result:", result
end program test_function

function multiply_add(a, b, c)

real :: multiply_add
real, intent(in) :: a, b, c
multiply_add = a * b + c
end function multiply_add

Explanation:

  • multiply_add receives three parameters.
  • It calculates a * b + c.
  • Functions with multiple arguments simplify complex calculations into a single reusable block.

5. Functions with Different Data Types

Functions can accept arguments of different types: integers, real numbers, logicals, or characters.

Example: Mixed Types

function compute(a, b, flag)

real :: compute
real, intent(in) :: a, b
logical, intent(in) :: flag


if (flag) then
    compute = a + b
else
    compute = a * b
end if
end function compute

program test

real :: result
result = compute(2.0, 3.0, .true.)
print *, "Result with flag true:", result


result = compute(2.0, 3.0, .false.)
print *, "Result with flag false:", result
end program test
  • Output:
Result with flag true: 5.0
Result with flag false: 6.0
  • Demonstrates the flexibility of multiple arguments in controlling function behavior.

6. Using Functions for Mathematical Calculations

Functions with multiple arguments are ideal for mathematical formulas:

Example: Quadratic Equation

function quadratic(a, b, c, x)

real :: quadratic
real, intent(in) :: a, b, c, x
quadratic = a*x**2 + b*x + c
end function quadratic

program test_quadratic

real :: value
value = quadratic(2.0, -3.0, 1.0, 4.0)
print *, "Quadratic value:", value
end program test_quadratic
  • Input: coefficients a, b, c and variable x.
  • Calculates 2*4^2 - 3*4 + 1 = 21.

7. Functions with Multiple Arguments in Arrays

Functions can accept arrays as arguments alongside scalar values.

Example: Sum of Array with Offset

function sum_with_offset(arr, offset)

real :: sum_with_offset
real, intent(in) :: arr(:), offset
integer :: i


sum_with_offset = 0.0
do i = 1, size(arr)
    sum_with_offset = sum_with_offset + arr(i) + offset
end do
end function sum_with_offset

program test_array

real :: arr(5) = (/1,2,3,4,5/)
real :: result
result = sum_with_offset(arr, 2.0)
print *, "Sum with offset:", result
end program test_array
  • Adds each element of the array plus an offset.
  • Output:
Sum with offset: 25.0

8. Nested Function Calls with Multiple Arguments

Functions can be called inside other functions.

function multiply_add(a, b, c)

real :: multiply_add
real, intent(in) :: a, b, c
multiply_add = a * b + c
end function multiply_add

function complex_calc(x, y, z)

real :: complex_calc
real, intent(in) :: x, y, z
complex_calc = multiply_add(x, y, z) / 2.0
end function complex_calc

program test

real :: result
result = complex_calc(2.0, 3.0, 4.0)
print *, "Complex calculation result:", result
end program test
  • multiply_add is called within complex_calc.
  • Demonstrates modular programming and function reusability.

9. Optional Arguments

Fortran allows optional arguments in functions.

function multiply_add_optional(a, b, c)

real :: multiply_add_optional
real, intent(in) :: a, b
real, intent(in), optional :: c


if (present(c)) then
    multiply_add_optional = a*b + c
else
    multiply_add_optional = a*b
end if
end function multiply_add_optional

program test

real :: result1, result2
result1 = multiply_add_optional(2.0, 3.0, 4.0)
result2 = multiply_add_optional(2.0, 3.0)
print *, "With c:", result1
print *, "Without c:", result2
end program test
  • present(c) checks if the optional argument is provided.
  • Output:
With c: 10.0
Without c: 6.0

10. Functions with Keyword Arguments

Keyword arguments allow passing values out of order.

result = multiply_add(a=2.0, c=4.0, b=3.0)
  • The function still correctly computes 2*3 + 4 = 10.
  • Improves readability in functions with multiple arguments.

11. Passing Functions as Arguments

Functions with multiple arguments can also accept other functions as arguments using procedure pointers, enabling higher-order programming.

Example: Using a Function Inside Another

function apply_operation(x, y, func)

real :: apply_operation
real, intent(in) :: x, y
interface
    function func(a, b)
        real :: func
        real, intent(in) :: a, b
    end function func
end interface


apply_operation = func(x, y)
end function apply_operation

function add(a, b)

real :: add
real, intent(in) :: a, b
add = a + b
end function add

program test

real :: result
result = apply_operation(2.0, 3.0, add)
print *, "Result of addition:", result
end program test
  • Demonstrates higher-order functions in Fortran.

12. Real-World Applications

  1. Mathematical computations – polynomial evaluation, physics formulas, engineering models.
  2. Data processing – apply transformations to multiple inputs.
  3. Scientific simulations – handling parameters for models.
  4. Modular programs – functions with multiple arguments simplify code reuse.
  5. Financial calculations – interest, tax, or loan computation with multiple input parameters.

13. Best Practices

  1. Use intent(in) for arguments that should not be modified.
  2. Name arguments descriptively – improves readability.
  3. Use optional arguments when some inputs are not always required.
  4. Document each argument – clarify units, expected ranges, and purpose.
  5. Modularize code – combine small reusable functions instead of long monolithic functions.

14. Common Pitfalls

  1. Mismatched types – ensure argument types match expected types.
  2. Missing arguments – provide required arguments when not optional.
  3. Side effects – avoid modifying arguments unless intent(out) or intent(inout) is used.
  4. Excessive arguments – too many arguments may reduce readability; consider derived types.

Comments

Leave a Reply

Your email address will not be published. Required fields are marked *