Type Conversion in Fortran

Type conversion is an essential concept in programming, allowing a programmer to convert data from one type to another. In Fortran, type conversion is performed using intrinsic functions, which provide a simple and effective way to ensure that calculations and operations between different data types are accurate and predictable.

1. Introduction to Type Conversion

Fortran is a strongly typed language, meaning that each variable has a defined type, such as integer, real, double precision, complex, or character. Operations involving mismatched types can result in errors or unexpected results.

Type conversion allows programmers to:

• Perform arithmetic operations between different types.
• Ensure accurate calculations by controlling precision.
• Interact with input/output systems where types may differ.

Fortran provides intrinsic functions for type conversion, such as:

• int() – Converts to integer.
• real() – Converts to single-precision real.
• dble() – Converts to double-precision real.
• aimag() – Returns the imaginary part of a complex number.
• abs() – Returns absolute value (works for integers, real, and complex numbers).

2. Converting Integer to Real

Often, integer values are converted to real numbers for division or other floating-point calculations. Without conversion, integer division truncates the result.

Example:

integer :: i
real :: x
i = 5
x = real(i) / 2.0
print *, "x =", x

Explanation:

• i is an integer with value 5.
• real(i) converts i to a real number (5.0).
• Division by 2.0 yields a floating-point result 2.5.
• Without real(i), 5/2 would perform integer division, resulting in 2.

---

3. Converting Real to Integer

Converting real numbers to integers is useful when working with array indices, loop counters, or any scenario requiring whole numbers.

real :: y
integer :: j
y = 3.7
j = int(y)
print *, "Integer value:", j

Explanation:

• int(y) truncates the fractional part of y.
• The result is 3.
• If rounding is desired, use nint() instead of int().

Example with nint:

integer :: k
k = nint(y)
print *, "Rounded integer value:", k

• nint(y) rounds 3.7 to 4.

---

4. Single to Double Precision Conversion

Fortran supports single and double precision real numbers. Converting between these ensures accurate calculations in scientific applications.

real :: x
double precision :: y
x = 3.14
y = dble(x)
print *, "Double precision value:", y

Explanation:

• dble(x) converts single precision x to double precision.
• This is critical in high-precision calculations such as simulations, physics computations, and engineering applications.

---

5. Converting Between Complex and Real

Complex numbers have both real and imaginary parts. Fortran provides functions to extract these parts or convert to other types:

• real(z) – Extracts the real part.
• aimag(z) – Extracts the imaginary part.
• abs(z) – Returns the magnitude.

Example:

complex :: z
real :: re, im, mag
z = (3.0, 4.0)

re = real(z)
im = aimag(z)
mag = abs(z)

print *, "Real part:", re
print *, "Imaginary part:", im
print *, "Magnitude:", mag

Output:

Real part: 3.0
Imaginary part: 4.0
Magnitude: 5.0

---

6. Converting Character to Numeric

Fortran allows conversion between character strings and numeric types using read or internal file methods.

Example:

character(len=10) :: str
integer :: i
real :: x

str = '42'
read(str,*) i
print *, "Integer value:", i

str = '3.14'
read(str,*) x
print *, "Real value:", x

Explanation:

• The read(str,*) statement reads the character string as a numeric value.
• This is useful when reading numbers from text files or user input.

---

7. Converting Numeric to Character

Numeric values can be converted to strings using write to an internal file:

integer :: i
real :: x
character(len=20) :: str

i = 42
x = 3.14159

write(str,'(I5)') i
print *, "Integer as string:", str

write(str,'(F10.3)') x
print *, "Real as string:", str

Explanation:

• Using an internal file in write, numeric values are formatted and stored as character strings.
• Useful for creating reports, logging, or file output with formatted text.

---

8. Mixed-Type Expressions

In many cases, expressions involve variables of different types. Fortran automatically promotes types in expressions, but explicit type conversion ensures clarity and correctness.

Example:

integer :: a
real :: b, result

a = 7
b = 2.5
result = real(a) + b
print *, "Result =", result

Explanation:

• a is converted to real before addition.
• Avoids unintended integer arithmetic.
• Explicit conversion improves code readability.

---

9. Converting Between Different Kinds

Fortran allows specifying kind parameters to control precision. Type conversion between kinds is common in scientific applications.

integer :: i
real(kind=8) :: x  ! double precision
i = 5
x = real(i, kind=8) / 2.0
print *, "x =", x

Explanation:

• real(i, kind=8) converts i to double precision.
• Ensures consistency in high-precision calculations.

---

10. Conversion Functions Summary

Function	Description
int(x)	Converts x to integer (truncates decimal).
nint(x)	Converts x to integer (rounds to nearest integer).
real(x)	Converts x to single precision real.
dble(x)	Converts x to double precision real.
aimag(z)	Returns imaginary part of complex number z.
abs(x)	Returns absolute value of numeric or magnitude of complex.
conjg(z)	Returns conjugate of complex number.

Using these functions, programmers can handle type mismatches efficiently.

---

11. Practical Examples

Example 1: Division with Integers

integer :: a, b
real :: result
a = 5
b = 2
result = real(a) / real(b)
print *, "Result =", result

• Converts both integers to real for accurate floating-point division.

---

Example 2: Combining Complex and Real

complex :: z
real :: r
z = (3.0, 4.0)
r = abs(z) / 2.0
print *, "Half magnitude =", r

• Combines complex magnitude with real division.

---

Example 3: Reading Mixed Data

character(len=20) :: str
integer :: i
real :: x

str = '10 3.14'
read(str,*) i, x
print *, "Integer:", i
print *, "Real:", x

• Converts character input to numeric types for calculations.

---

12. Common Pitfalls

1. Integer division: Always convert to real for fractional results.
2. Loss of precision: Converting double precision to single may lose accuracy.
3. Implicit conversion errors: Relying on automatic promotion can cause unintended behavior.
4. Complex-real mismatches: Always extract real(z) or aimag(z) when needed.

---

13. Best Practices

1. Explicit conversion improves clarity.
2. Use kind parameters for high-precision calculations.
3. Always verify conversions when reading from files or user input.
4. Combine conversion functions with formatting for output reports.
5. Document conversions in scientific code to avoid confusion.