Educational

Arithmetic Operators Addition and Subtraction in Fortran

—

by

Saim Khalid
in

Fortran is a powerful language widely used in scientific computing, engineering, and numerical simulations. One of the most fundamental aspects of programming in Fortran is performing arithmetic operations. Among these, addition and subtraction are the most basic and commonly used operations. These operators can be applied to integer, real, and double precision variables to perform calculations, update values, and solve numerical problems.

This post provides a comprehensive discussion on the use of addition (+) and subtraction (-) in Fortran, including syntax, examples, use with different data types, best practices, and advanced applications.

1. Introduction to Arithmetic Operators

Arithmetic operators are symbols that represent mathematical operations. In Fortran, the four primary arithmetic operators are:

  1. Addition (+)
  2. Subtraction (-)
  3. Multiplication (*)
  4. Division (/)

In this post, we will focus on addition and subtraction, which are used for summing values and computing differences.

2. Addition Operator (+)

The addition operator + is used to calculate the sum of two or more numbers. It can be applied to integer, real, and double precision variables.

Syntax:

result = operand1 + operand2

Example with Integers:

program addition_integer

integer :: x, y, sum
x = 10
y = 4
sum = x + y
print *, "Sum:", sum
end program addition_integer

Explanation:

  • x and y are integer variables.
  • The + operator adds x and y, and the result is stored in sum.
  • The print * statement displays the sum.

2.1 Addition with Real Numbers

Addition can also be applied to floating-point numbers:

program addition_real

real :: a, b, sum
a = 3.5
b = 2.1
sum = a + b
print *, "Sum:", sum
end program addition_real

Explanation:

  • Real variables a and b are added to produce a real result.
  • Addition with real numbers is commonly used in scientific computations.

2.2 Addition with Double Precision

Double precision provides higher accuracy for floating-point numbers:

program addition_double

double precision :: x, y, sum
x = 3.1415926535
y = 2.7182818284
sum = x + y
print *, "Sum (double precision):", sum
end program addition_double

Explanation:

  • Double precision variables maintain high accuracy.
  • Addition with double precision is important for numerical simulations that require precision.

3. Subtraction Operator (-)

The subtraction operator - calculates the difference between two numbers.

Syntax:

result = operand1 - operand2

Example with Integers:

program subtraction_integer

integer :: x, y, diff
x = 10
y = 4
diff = x - y
print *, "Difference:", diff
end program subtraction_integer

Explanation:

  • The operator - subtracts y from x and stores the result in diff.
  • Subtraction is essential in computing differences, offsets, and changes in values.

3.1 Subtraction with Real Numbers

program subtraction_real

real :: a, b, diff
a = 5.75
b = 2.25
diff = a - b
print *, "Difference:", diff
end program subtraction_real

Explanation:

  • Floating-point subtraction is widely used in calculations involving measurements, distances, or scientific formulas.

3.2 Subtraction with Double Precision

program subtraction_double

double precision :: x, y, diff
x = 10.123456789
y = 3.987654321
diff = x - y
print *, "Difference (double precision):", diff
end program subtraction_double

Explanation:

  • Double precision ensures accuracy in subtraction operations where small differences are significant.

4. Combining Addition and Subtraction

Addition and subtraction can be combined in a single expression:

program combined_operations

integer :: a, b, c, result
a = 10
b = 5
c = 3
result = a + b - c
print *, "Result of a + b - c:", result
end program combined_operations

Explanation:

  • Expressions are evaluated left to right.
  • Parentheses can be used to control the order of operations if needed:
result = a + (b - c)

5. Use in Loops

Integer addition and subtraction are often used to control loops:

program loop_addition

integer :: i, sum
sum = 0
do i = 1, 5
    sum = sum + i
end do
print *, "Sum of first 5 numbers:", sum
end program loop_addition

Explanation:

  • Loop variable i adds values to sum on each iteration.
  • Addition within loops is essential for cumulative sums and counting.

5.1 Subtraction in Loops

program loop_subtraction

integer :: i, value
value = 20
do i = 1, 5
    value = value - 2
    print *, "Value after subtraction:", value
end do
end program loop_subtraction

Explanation:

  • Each iteration reduces value by 2 using subtraction.
  • Subtraction is often used in decrementing counters or updating values in loops.

6. Addition and Subtraction with Arrays

Integer or real arrays can also use addition and subtraction operations:

program array_operations

integer, dimension(5) :: arr1, arr2, sum_array, diff_array
integer :: i


arr1 = (/1, 2, 3, 4, 5/)
arr2 = (/5, 4, 3, 2, 1/)


do i = 1, 5
    sum_array(i) = arr1(i) + arr2(i)
    diff_array(i) = arr1(i) - arr2(i)
end do


print *, "Sum Array:", sum_array
print *, "Difference Array:", diff_array
end program array_operations

Explanation:

  • Each element of arr1 is added to or subtracted from the corresponding element of arr2.
  • Array arithmetic is widely used in scientific calculations, simulations, and data processing.

7. Best Practices

  1. Use parentheses to clarify expressions: Even though addition and subtraction are evaluated left to right, parentheses improve readability.
  2. Initialize variables before use: Avoid undefined behavior in calculations.
  3. Use appropriate data types: Choose integer for counting and indexing, real or double precision for fractional numbers.
  4. Document expressions: Complex arithmetic expressions should be documented for clarity.
  5. Avoid mixing types without conversion: Use real() or int() functions if needed.

8. Advanced Examples

8.1 Addition in Expressions with Real and Integer

program mixed_addition

integer :: a = 5
real :: b = 2.5, result
result = a + b
print *, "Result of integer + real:", result
end program mixed_addition

Explanation:

  • Fortran automatically converts integer a to real before performing addition with b.

8.2 Subtraction in Conditional Statements

program subtraction_condition

integer :: x = 10, y = 4, diff
diff = x - y
if (diff > 5) then
    print *, "Difference is greater than 5"
else
    print *, "Difference is 5 or less"
end if
end program subtraction_condition

Explanation:

  • Subtraction can be used directly in conditional statements to control program flow.

8.3 Using Addition and Subtraction in Functions

program functions_add_sub

real :: result
result = calculate(10.5, 2.3)
print *, "Result:", result

contains


function calculate(a, b)
    real :: calculate, a, b
    calculate = a + b - 1.0
end function calculate

end program functions_add_sub

Explanation:

  • Functions can perform addition and subtraction and return results.
  • Modular arithmetic operations improve code reusability.

9. Summary

  • Addition (+) and subtraction (-) are basic arithmetic operations in Fortran.
  • They can be applied to integers, real numbers, and double precision variables.
  • Proper initialization of variables ensures correct calculations.
  • Addition and subtraction can be used in loops, arrays, functions, and conditional statements.
  • Best practices include using parentheses for clarity, initializing variables, and choosing the appropriate data type.
  • These operators form the foundation of all numerical calculations in Fortran programs.

10. Complete Example

program arithmetic_demo

implicit none
integer :: x = 10, y = 4, sum, diff
real :: a = 3.5, b = 1.2, real_sum, real_diff
double precision :: p = 3.141592, q = 2.718281, dp_sum, dp_diff


! Integer addition and subtraction
sum = x + y
diff = x - y
print *, "Integer Sum:", sum
print *, "Integer Difference:", diff


! Real addition and subtraction
real_sum = a + b
real_diff = a - b
print *, "Real Sum:", real_sum
print *, "Real Difference:", real_diff


! Double precision addition and subtraction
dp_sum = p + q
dp_diff = p - q
print *, "Double Precision Sum:", dp_sum
print *, "Double Precision Difference:", dp_diff

end program arithmetic_demo

Explanation:

  • Demonstrates addition and subtraction for integer, real, and double precision variables.
  • Shows how initialization and proper variable declaration ensure accurate calculations.

Comments

Leave a Reply

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