Fortran - Số

Các con số trong Fortran được đại diện bởi ba kiểu dữ liệu nội tại -

Kiểu số nguyên
Loại thực
Loại phức tạp

Loại số nguyên

Các kiểu số nguyên chỉ có thể chứa các giá trị nguyên. Ví dụ sau đây trích xuất giá trị lớn nhất có thể được giữ trong một số nguyên bốn byte thông thường:

program testingInt
implicit none

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

Khi bạn biên dịch và thực thi chương trình trên, nó tạo ra kết quả sau:

2147483647

Xin lưu ý rằng huge()hàm cung cấp số lớn nhất có thể được giữ bởi kiểu dữ liệu số nguyên cụ thể. Bạn cũng có thể chỉ định số byte bằng cách sử dụngkindngười chỉ định. Ví dụ sau đây chứng minh điều này -

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

Khi bạn biên dịch và thực thi chương trình trên, nó tạo ra kết quả sau:

32767
2147483647
9223372036854775807
170141183460469231731687303715884105727
2147483647

Loại thực

Nó lưu trữ các số dấu phẩy động, chẳng hạn như 2.0, 3.1415, -100.876, v.v.

Theo truyền thống, có hai real loại: loại thực mặc định và double precision kiểu.

Tuy nhiên, Fortran 90/95 cung cấp nhiều quyền kiểm soát hơn đối với độ chính xác của các kiểu dữ liệu số nguyên và thực thông qua kind specifier, mà chúng ta sẽ nghiên cứu ngay sau đây.

Ví dụ sau cho thấy việc sử dụng kiểu dữ liệu thực:

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

Khi bạn biên dịch và thực thi chương trình trên, nó tạo ra kết quả sau:

0.666666687    
0

Loại phức tạp

Điều này được sử dụng để lưu trữ các số phức. Một số phức có hai phần: phần thực và phần ảo. Hai đơn vị lưu trữ số liên tiếp lưu trữ hai phần này.

Ví dụ: số phức (3.0, -5.0) bằng 3.0 - 5.0i

Hàm chung cmplx()tạo ra một số phức. Nó tạo ra một kết quả là phần thực và phần ảo là độ chính xác duy nhất, bất kể loại đối số đầu vào.

program createComplex
implicit none

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

Khi bạn biên dịch và thực thi chương trình trên, nó tạo ra kết quả sau:

(10.0000000, 5.17000008)

Chương trình sau đây biểu diễn số học phức:

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

Khi bạn biên dịch và thực thi chương trình trên, nó tạo ra kết quả sau:

(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)

Phạm vi, độ chính xác và kích thước của các con số

Phạm vi trên số nguyên, độ chính xác và kích thước của số dấu phẩy động phụ thuộc vào số bit được phân bổ cho kiểu dữ liệu cụ thể.

Bảng sau đây hiển thị số bit và phạm vi cho các số nguyên:

Số lượng bit	Gia trị lơn nhât	Lý do
64	9.223.372.036.854.774.807	(2 ** 63) –1
32	2.147.483.647	(2 ** 31) –1

Bảng sau đây hiển thị số bit, giá trị nhỏ nhất và lớn nhất và độ chính xác của các số thực.

Số lượng bit	Giá trị lớn nhất	Giá trị nhỏ nhất	Độ chính xác
64	0,8E + 308	0,5E – 308	15–18
32	1,7E + 38	0,3E – 38	6-9

Các ví dụ sau đây chứng minh điều này -

program rangePrecision
implicit none

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

Khi bạn biên dịch và thực thi chương trình trên, nó tạo ra kết quả sau:

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)

Bây giờ chúng ta hãy sử dụng một số nhỏ hơn -

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

Khi bạn biên dịch và thực thi chương trình trên, nó tạo ra kết quả sau:

Infinity
0.402144760

Bây giờ chúng ta hãy xem quy trình dưới đây -

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

Khi bạn biên dịch và thực thi chương trình trên, nó tạo ra kết quả sau:

y = 3.73e-60
           1
Warning : Real constant underflows its kind at (1)

Executing the program....
$demo 

0.00000000E+00
Infinity

Bộ chỉ định loại

Trong lập trình khoa học, người ta thường cần biết phạm vi và độ chính xác của dữ liệu của nền tảng phần cứng mà công việc đang được thực hiện.

Chức năng nội tại kind() cho phép bạn truy vấn chi tiết về các biểu diễn dữ liệu của phần cứng trước khi chạy một chương trình.

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

Khi bạn biên dịch và thực thi chương trình trên, nó tạo ra kết quả sau:

Integer 4
Real 4
Complex 4

Bạn cũng có thể kiểm tra loại của tất cả các loại dữ liệu -

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

Khi bạn biên dịch và thực thi chương trình trên, nó tạo ra kết quả sau:

Integer 4
Real 4
Complex 4
Character 1
Logical 4