Fortran编程（基础语法）——笔记3

Posted 2022-11-24 大作家佚名

Fortran - Basic 语法

每个程序包含一个主程序，可能包含也可能不包含其他程序单元。 主程序的语法如下：

! 所有Fortran程序都以关键字program开头，以关键字end program,后跟end program,名称。
! implicit none语句允许编译器检查是否正确声明了所有变量类型。 您必须始终在每个程序的开头使用implicit none 。
! Fortran中的注释以感叹号（!）开头，因为编译器会忽略此后的所有字符（字符串除外）。
! print *命令在屏幕上显示数据。
! 压缩代码行是保持程序可读性的好方法。
! Fortran允许使用大写和小写字母。 除字符串文字外，Fortran不区分大小写。

        program program_name
        	! 关闭隐式类型
            implicit none      
            ! type declaration statements      
            ! executable statements  
            print *,"Hello,World!"
            read(*,*)
        end program program_name

让我们编写一个程序，添加两个数字并打印结果 ：

        program addNumbers
            ! This simple program adds two numbers
            implicit none
            ! Type declarations
            real :: a, b, result
            ! Executable statements
            a = 12.0
            b = 15.0
            result = a + b
            print *, 'The total is ', result
        end program addNumbers

Fortran变量

变量的名称可以由字母，数字和下划线字符组成。 Fortran中的名称必须遵循以下规则 :
（1）它不能超过31个字符。
（2）它必须由字母数字字符（字母表中的所有字母，数字0到9）和下划线（_）组成。
（3）名称的第一个字符必须是字母。
（4）名称不区分大小写。

变量声明 (Variable Declaration)

变量在类型声明语句中的程序（或子程序）的开头声明。
变量声明的语法如下 -

type-specifier :: variable_name

例子 (Example)

以下示例演示了屏幕上的变量声明，分配和显示 -

        program variableTesting
            implicit none
            ! declaring variables 变量声明
            integer :: total      
            real :: average 
            complex :: cx  
            logical :: done 
            character(len=80) :: message ! a string of 80 characters

            !assigning values 赋值
            total = 20000  
            average = 1666.67   
            done = .true.   
            message = "A big Hello from IOWIKI" 
            cx = (3.0, 5.0) ! cx = 3.0 + 5.0i
            Print *, total
            Print *, average
            Print *, cx
            Print *, done
            Print *, message
        end program variableTesting

Fortran - 常量

常量是指程序在执行期间无法更改的固定值。命名常量具有值和名称。命名常量应在程序或过程的开头声明，就像变量类型声明一样，指示其名称和类型。使用parameter属性声明命名常量。例如，

例子 (Example)

以下程序计算重力作用下垂直运动引起的位移。

real, parameter :: pi = 3.1415927

        program gravitationalDisp

            ! this program calculates vertical motion under gravity 
            implicit none  

            ! gravitational acceleration
            real, parameter :: g = 9.81   
            
            ! variable declaration
            real :: s ! displacement   
            real :: t ! time  
            real :: u ! initial speed  
            
            ! assigning values 
            t = 5.0   
            u = 50  
            
            ! displacement   
            s = u * t - g * (t**2) / 2  
            
            ! output 
            print *, "Time = ", t
            print *, 'Displacement = ',s  
        
        end program gravitationalDisp

Fortran - 运算符

Fortran提供以下类型的运算符 ：算术运算符、关系运算符、逻辑运算符。

算术运算符 (Arithmetic Operators)

下表显示了Fortran支持的所有算术运算符。 假设变量A=5，变量B=3然后

操作	描述	值
+	加法运算符，添加两个操作数。	A + B将给出8
-	减法运算符，从第一个减去第二个操作数。	A - B将给2
*	乘法运算符，将两个操作数相乘。	A * B将给出15
/	除法运算符，用除分子除分子。	A/B将给1
**	指数运算符，将一个操作数提升到另一个操作数。	A ** B将给出125

例子 (Example)

! 尝试以下示例来了解Fortran中可用的所有算术运算符 -

        program arithmeticOp
            ! this program performs arithmetic calculation
            implicit none  
            ! variable declaration
            integer :: a, b, c
            ! assigning values 
            a = 5   
            b = 3  
            ! Exponentiation 
            c = a ** b 
            ! output 
            print *, "c = ", c
            ! Multiplication  
            c = a * b 
            ! output 
            print *, "c = ", c
            ! Division  
            c = a/b 
            ! output 
            print *, "c = ", c
            ! Addition
            c = a + b 
            ! output 
            print *, "c = ", c
            ! Subtraction 
            c = a - b 
            ! output 
            print *, "c = ", c
        end program arithmeticOp

关系运算符 (Relational Operators)

下表显示了Fortran支持的所有关系运算符。 假设变量A=10，变量B=20，则

操作	符号	描述	结果
==	.eq.	检查两个操作数的值是否相等，如果是，则条件变为真。	（A == B）不是真的。
/=	.ne.	检查两个操作数的值是否相等，如果值不相等则条件变为真。	（A！= B）是真的。
>	.gt.	检查左操作数的值是否大于右操作数的值，如果是，则条件变为真。	（A> B）不是真的。
<	.lt.	检查左操作数的值是否小于右操作数的值，如果是，则条件变为真。	(A < B) 为真
>=	.ge.	检查左操作数的值是否大于或等于右操作数的值，如果是，则条件变为真。	（A> = B）不是真的。
<=	.le.	检查左操作数的值是否小于或等于右操作数的值，如果是，则条件变为真。	（A <= B）是真的。

逻辑运算符 (Logical Operators)

Fortran中的逻辑运算符仅适用于逻辑值.true 和.false。

下表显示了Fortran支持的所有逻辑运算符。 假设变量A .true。 变量B .false。 那么 -

操作	描述	结果
.and.	称为逻辑AND运算符。 如果两个操作数都不为零，则条件成立。	（A.and.B）是假的。
.or.	称为逻辑OR运算符。 如果两个操作数中的任何一个非零，则条件变为真。	（A.or.B）是真的。
.not.	称为逻辑非运算符。 用于反转其操作数的逻辑状态。 如果条件为真，则Logical NOT运算符将为false。	！（A.not.B）是真的。
.eqv.	称为逻辑等效运算符。 用于检查两个逻辑值的等效性。	（A .eqv.B）是假的。
.neqv.	称为逻辑非等价运算符。 用于检查两个逻辑值的非等价性。	（A .neqv.B）是真的。

例子 (Example)

        program logicalOp
            ! this program checks logical operators
            implicit none  
            ! variable declaration
            logical :: a, b
            ! assigning values 
            a = .true.   
            b = .false. 
            if (a .and. b) then
                print *, "Line 1 - Condition is true"
            else
                print *, "Line 1 - Condition is false"
            end if
            if (a .or. b) then
                print *, "Line 2 - Condition is true"
            else
                print *, "Line 2 - Condition is false"
            end if
            ! changing values 
            a = .false.   
            b = .true. 
            if (.not.(a .and. b)) then
                print *, "Line 3 - Condition is true"
            else
                print *, "Line 3 - Condition is false"
            end if
            if (b .neqv. a) then
                print *, "Line 4 - Condition is true"
            else
                print *, "Line 4 - Condition is false"
            end if
            if (b .eqv. a) then
                print *, "Line 5 - Condition is true"
            else
                print *, "Line 5 - Condition is false"
            end if
        end program logicalOp

Fortran中的运算符优先级

运算符优先级确定表达式中的术语分组。 这会影响表达式的计算方式。 某些运算符的优先级高于其他运算符; 例如，乘法运算符的优先级高于加法运算符。

例子 (Example)

        program precedenceOp
            ! this program checks logical operators
            implicit none  
            ! variable declaration
            integer :: a, b, c, d, e
            ! assigning values 
            a = 20   
            b = 10
            c = 15
            d = 5
            e = (a + b) * c/d      ! ( 30 * 15 )/5
            print *, "Value of (a + b) * c/d is :    ",  e 
            e = ((a + b) * c)/d    ! (30 * 15 )/5
            print *, "Value of ((a + b) * c)/d is  : ",  e 
            e = (a + b) * (c/d);   ! (30) * (15/5)
            print *, "Value of (a + b) * (c/d) is  : ",  e 
            e = a + (b * c)/d;     !  20 + (150/5)
            print *, "Value of a + (b * c)/d is  :   " ,  e 
        end program precedenceOp