Fortran數字

Fortran的數字由三個內部數據類型來表示：

• 整型
• 實型
• 複雜類型

整型

整數類型只能容納整數值。下麵的例子中提取的是持有一個通常的4位元組整數的最大值：

program testingInt
implicit none

   integer :: largeval
   print *, huge(largeval)

end program testingInt

當編譯並執行上述程式，將產生以下結果：

2147483647

請注意，huge()函數給出能夠由特定的整數數據類型可以保持的最大數字。還可以指定使用的那種符的位元組數。下麵的例子說明了這一點：

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提供了更多的控制權實數和整數數據類型，通過一種說明，我們將在較短期內學習研究精度。

下麵的例子展示了如何使用實型的數據類型：

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*1 :: 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