Fortran 数值

Fortran 中的数字由 3 种固有数据类型表示：

• 整数类型
• 真实类型
• 复数类型

整数类型

整数类型只能包含整数值。以下示例提取了通常四字节整数中可以容纳的最大值：

program testingInt
implicit none
   integer :: largeval
   print *, huge(largeval)
end program testingInt

结果为：

2147483647

请注意，huge() 函数给出了特定整数数据类型可以容纳的最大数字。您还可以使用 kind 说明符指定字节数。以下实例演示了这一点：

program testingInt
implicit none
   !two byte integer
   integer(kind = 2) :: shortval
   !four byte integer
   integer(kind = 4) :: longval
   !eight byte integer
   integer(kind = 8) :: verylongval
   !sixteen byte integer
   integer(kind = 16) :: veryverylongval
   !default integer
   integer :: defval
   print *, huge(shortval)
   print *, huge(longval)
   print *, huge(verylongval)
   print *, huge(veryverylongval)
   print *, huge(defval)
end program testingInt

结果为：

32767
2147483647
9223372036854775807
170141183460469231731687303715884105727
2147483647

真实类型

它存储浮点数，如2.0、3.1415、-100.876等。

传统上有两种不同的实数类型：默认实数类型和双精度类型。

然而，Fortran 90/95 通过 kind 说明符提供了对实数和整数数据类型精度的更多控制，我们稍后将对此进行研究。

以下实例显示了真实数据类型的使用：

program division
implicit none
   ! Define real variables
   real :: p, q, realRes
   ! Define integer variables
   integer :: i, j, intRes
   ! Assigning  values
   p = 2.0
   q = 3.0
   i = 2
   j = 3
   ! floating point division
   realRes = p/q
   intRes = i/j
   print *, realRes
   print *, intRes
end program division

结果为：

0.666666687
0

复数类型

它用于存储复数。复数有两部分：实部和虚部。两个连续的数字存储单元存储这两个部分。

例如，复数 (3.0，-5.0) 等于 3.0–5.0i

通用函数 cmplx() 创建一个复数。它产生的结果是，无论输入参数的类型如何，实部和虚部都是单精度的。

program createComplex
implicit none
   integer :: i = 10
   real :: x = 5.17
   print *, cmplx(i, x)
end program createComplex

结果为：

(10.0000000, 5.17000008)

以下实例演示复数运算：

program ComplexArithmatic
implicit none
   complex, parameter :: i = (0, 1)   ! sqrt(-1)
   complex :: x, y, z
   x = (7, 8);
   y = (5, -7)
   write(*,*) i * x * y
   z = x + y
   print *, "z = x + y = ", z
   z = x - y
   print *, "z = x - y = ", z
   z = x * y
   print *, "z = x * y = ", z
   z = x / y
   print *, "z = x / y = ", z
end program ComplexArithmatic

结果为：

(9.00000000, 91.0000000)
z = x + y = (12.0000000, 1.00000000)
z = x - y = (2.00000000, 15.0000000)
z = x * y = (91.0000000, -9.00000000)
z = x / y = (-0.283783793, 1.20270276)

数字的范围、精度和大小

整数的范围、精度和浮点数的大小取决于分配给特定数据类型的位数。

下表显示了整数的位数和范围：

下表显示了位数、最小值和最大值以及精度：

下面的实例演示：

program rangePrecision
implicit none
   real:: x, y, z
   x = 1.5e+40
   y = 3.73e+40
   z = x * y
   print *, z
end program rangePrecision

结果为：

x = 1.5e+40
          1
Error : Real constant overflows its kind at (1)
main.f95:5.12:
y = 3.73e+40
           1
Error : Real constant overflows its kind at (1)

让我们使用一个最小值：

program rangePrecision
implicit none
   real:: x, y, z
   x = 1.5e+20
   y = 3.73e+20
   z = x * y
   print *, z
   z = x/y
   print *, z
end program rangePrecision

结果为：

Infinity
0.402144760

再来看看这个实例：

program rangePrecision
implicit none
   real:: x, y, z
   x = 1.5e-30
   y = 3.73e-60
   z = x * y
   print *, z
   z = x/y
   print *, z
end program rangePrecision

结果为：

y = 3.73e-60
           1
Warning : Real constant underflows its kind at (1)
Executing the program....
$demo
0.00000000E+00
Infinity

Kind 指定符

在科学编程中，人们通常需要知道正在进行工作的硬件平台的数据范围和精度。

内部函数 kind() 允许您在运行程序之前查询硬件数据表示的详细信息。

program kindCheck
implicit none
   integer :: i
   real :: r
   complex :: cp
   print *,' Integer ', kind(i)
   print *,' Real ', kind(r)
   print *,' Complex ', kind(cp)
end program kindCheck

结果为：

Integer 4
Real 4
Complex 4

您还可以检查所有数据类型的类型：

program checkKind
implicit none
   integer :: i
   real :: r
   character :: c
   logical :: lg
   complex :: cp
   print *,' Integer ', kind(i)
   print *,' Real ', kind(r)
   print *,' Complex ', kind(cp)
   print *,' Character ', kind(c)
   print *,' Logical ', kind(lg)
end program checkKind

结果为：

Integer 4
Real 4
Complex 4
Character 1
Logical 4