Fortran 学习笔记

Implicit None 

Real(Kind=8) , parameter , private :: rVar = 20.0d0
Character(Len=32) , Intent( IN ) :: cStr(5,8)
Integer , save :: n = 30 , m = 40
Integer m
complex :: com
#如果( , )构造复数报错，可以使用cmplx(real,image)函数
yc(i)=cmplx(yr(i),yi(i)) 

! k = Selected_Int_Kind( i )  可以用这个函数来选择能满足要求的Kind
! i 表示需要最大的十进制位数
! k 表示返回的能满足范围的最小的Kind值	
! Selected_Int_Kind( i )函数可以放在声明语句里
integer , parameter :: KI=selected_int_kind(10)
integer(kind=KI) :: i1 i2 i3

! k = Selected_Real_Kind( r , p )  可以用这个函数来选择能满足要求的Kind
! r 表示需要最大的十进制位数 , p 表示最小的有效位数 p位*E^r
! k 表示返回的能满足范围的最小的Kind值
integer , parameter :: DP=selected_real_kind(r=50,p=14)
real(kind=DP) :: r1 r2

双精准度 - 使用两个双精准浮点数 
complex(kind=8) a ! F90新增作法 
complex(8)      a ! 
COMPLEX*16      a ! F77传统作法

! Initialize some variables(Double precision:dp=8)
      DUext = 0.0_dp
      Eharrs = 0.0_dp
      Eharrs1 = 0.0_dp

dp=8
call Pdgemm("N","N",2,8,2,1.0_dp,A,1,1,DESCA,B,1,1,DESCB,0.0_dp,C,1,1,DESCC)

character(len=32) :: str

INTEGER :: i
real :: ii
real(8) :: iii
write(*,*) "type:huge"
write(*,*) 'integer',huge(i)
write(*,*) 'real',huge(ii)
write(*,*) 'real(8)',huge(iii)

 type:huge
 integer  2147483647
 real   3.40282347E+38
 real(8)   1.7976931348623157E+308

complex :: com
com=(实部,虚部)

.NOT. ＞ .AND. ＞ .OR. ＞ .EQV. 和 .NEQV.

character(len=字符串长度) :: str

character(len=7) ::str
str="hello!!"
!gfortran 对这种写法报错 str(2)="12345"
!str(n:m)即可用于赋值，也可用来掉用
!str等价str(1:len(str))
!str(n:)等价str(n:len(str))
str(2:3)="tr"
write(*,*) str(3:3)

    syslab="  ---abc==="
    write(*,*) "adjustl"//adjustl(syslab)//"end"
    write(*,*) "adjustr"//adjustr(syslab)//"end"
    write(*,*) "trim"//trim(syslab)//"end"
    write(*,*) "trim(adjustl)"//trim(adjustl(syslab))//"end"

 #     |<                            >!
 adjustl---abc===                     end
 adjustr                     ---abc===end
 trim  ---abc===end
 trim(adjustl)---abc===end

str="hello,world"
WRITE(*,*) INDEX(str,"llo") !返回结果为3,即str中第3个元素及之后是llo

类型,形容词 :: 数组名(n1,n2,n3...维度)
类型,形容词 :: 数组名(n0:n1,m0:m1,...) 也可以，n0,m0也可从负数开始

类型,allocatable,其他形容词 :: 数组名(:,:,:....) !用:
!分配大小
allocate(array(N))
!释放空间
deallocate(array)

ALLOCATE(array(lb:ub))

ALLOCATE(b(-4:4))
DO i = -4,4
b(i) = i
ENDDO
WRITE(*,*) "b(-2:0)",b(-2:0)

b(-2:0)          -2          -1           0

  data((A(i,j),i=1,2),j=1,3) /1,2,3,4,5,6/
A=  
   1.00000000       3.00000000       5.00000000
   2.00000000       4.00000000       6.00000000
integer :: array(5),A(2,3)
!使用data赋值，后面的值要和前面的一一对应
array(1)=1
array(2:5)=3
data array /1,2,3,4,5/
data array /5*5/   !*表重复 /5,5,5,5,5/
data((A(i,j),i=1,2),j=1,3) /1,2,3,4,5,6/
！(f(I),i=1,5)就代表一组循环,i从1到5，输出f(i)，例如
A=(/(I*I,I=1,6)/)

!可直接进行调用或赋值
array(n,m)
array(n,:)
array(:)
A(:,:)

INTEGER     :: a(N),bound(1),i
bound=UBOUND(a)
i=bound(1)
i=UBOUND(a,1)

WRITE(*,"(A,I1,A,I4)") "max is a(",MAXLOC(a),"), which is",MAXVAL(a)
WRITE(*,"(A,I1,A,I4)") "min is a(",MINLOC(a),"), which is",MINVAL(a)

RESULT = ANY(MASK [, DIM])
ANY( (/.true., .false., .true./) )

IF( ANY( a .EQ. 0 ) ) WRITE(*,*) "At least one 0 in a"
IF( .NOT. ANY( a > 90 ) ) WRITE(*,*) "No one > 90 in a"

TYPE(结构体名) :: 变量名

      type :: student
              character :: nickname,address
              integer :: num,score
      end type
    
      type(student) :: xiaoming

结构体名%成员名 ！优先使用
结构体名.成员名 !gfortran好像不支持
xiaoming%nickname
xiaoming.num

TYPE(student)::xiaoming=student (“xiaoming","china",1,90), S2, S3
xiaoming.score=95

PROGRAM pointer_
IMPLICIT NONE
INTEGER,POINTER :: p1
INTEGER,TARGET :: i1,i2
!
NULLIFY(p1)
i1=1; i2=2
p1=>i1 ; WRITE(*,*) p1,ASSOCIATED(p1),ASSOCIATED(p1,i1),ASSOCIATED(p1,i2)
p1=>i1 ; WRITE(*,*) p1,ASSOCIATED(p1),ASSOCIATED(p1,i1),ASSOCIATED(p1,i2)
NULLIFY(p1) ; WRITE(*,*) p1,ASSOCIATED(p1),ASSOCIATED(p1,i1),ASSOCIATED(p1,i2)
END PROGRAM

cndaqiang@girl:~/code/test$ gfortran point.f90 ; ./a.out 
           1 T T F
           1 T T F
           0 F F F

!1，数字转字符
write(str1,"(i4.4)") num ! 如有需要，不足四位前面补零
print*,str1
!2，字符转数字
read(str1,"(i2)") num
print*,str1

IF(条件) 执行语句

IF (条件) THEN
执行语句
ELSE IF (条件) THEN
执行语句
ELSE IF (条件) THEN
执行语句
ELSE
执行语句
END IF
!ELSE IF与ELSE可不写

SELECT case (表达式)
case(A)
执行语句
case(B)
执行语句
END SELECT
!好像表达式结果只能为整数或字符串，A,B...也要对应

DO i=start,end [,step]
!步长step默认为1，可设置为正,负
！不写i=1,end 无穷循环
执行语句
END DO

DO WHILE(条件)
执行语句
END DO

cndaqiang@girl:~/code/test$ gfortran forall.f90 ; ./a.out 
           0           0           0           0           0
           6           6           6           6           6

cndaqiang@girl:~/code/test$ gfortran where.f90 ; ./a.out 
           1           1           1           4           4
           6           6           6           6           6
           1           2           3           4           5
           0           0           0           0           0

     read(unit,*) ika, ((eig(ib,is), ib = 1, nband), is = 1, nspin)
                        #此处先进行ib循环，再进行is循环

     write(*,100) 5
100  format(I5)
     write(*,"(spi5/ssf10.2)") 34 , 23.456

    5
  +34
     23.46

WRITE(funit,9035,advance="no") 
FLUSH(funit) #ifort要用这个确保不会换行

real :: a(10)
write(s,fmt="(a3,i3,a6)") "(a,",UBOUND(a,1),"f12.6)"
write(*,fmt=s) a

REAL(8) :: b(10)
b=1.0
write(*,10) b
10 FORMAT(1X,2E20.8)
!或者
write(*,"(1X,3E20.8)") b

[形容词][,返回类型] function 名称([虚参列表])
	[虚参声明]
	[局部变量定义]
	执行语句
	名称=返回值
	[return]
End [function [名称]]

返回变量=名称([实参列表])

CHARACTER(len=6), EXTERNAL :: int_to_char

Error: Function ‘int_to_char’ at (1) has no IMPLICIT type
td_analysis.f90:90:89:

[形容词] subroutine 名称([虚参列表])
	[虚参声明][局部变量定义]
	执行语句
	名称=返回值
	[return]
End [subroutine [名称]]

call 名称([实参列表])

program externalOrinterface
      implicit none
      real :: x,y
      real ,external :: fun !函数要声明
      x=1.0
      y=fun(x)
      write(*,*) y
      call sub(x)
end program externalOrinterface

real function fun(x)
      real :: x
      fun=x*x+1.0
end function fun

subroutine sub(x)
        real :: x,y
        y=x*x+1.0
        write(*,*) y
end subroutine sub

      interface 
             real function  fun(x)
                     real :: x
             end function fun
      end interface

(python27) ~/code/TDQE/Fortran/module_interface $ cat main.f90 
program main
    use m_interface
    integer :: aa(5),bb(5)
    aa=1
    bb=2
    call my_sum(aa(1),bb(1))
    call my_sum(aa,bb)
end program(python27) ~/code/TDQE/Fortran/module_interface $ cat module.f90 
module m_interface
    interface my_sum
     module procedure my_sum_integer
     module procedure my_sum_array
    end interface
contains
    subroutine my_sum_integer(a,b)
        INTEGER :: a,b
        write(*,*) "my_sum_integer:",a+b
    end subroutine
    subroutine my_sum_array(a,b)
        INTEGER ::a(:),b(:)
        write(*,*) "my_sum_array",a+b
    end subroutine
end module

mpif90 -c -g -O2 -ffree-line-length-none     module.f90
mpif90 -c -g -O2 -ffree-line-length-none     main.f90
mpif90  -g -O2 -ffree-line-length-none  -o interface  main.o module.o
./interface
 my_sum_integer:           3
 my_sum_array           3           3           3           3           3

real function fun(x)
      implicit none
      real ::x,y
      y=23.0
      fun=x*3.0
      fun=two(fun)
contains      !使用contains
      real function two(x)
        real ::x
        two=x*2.0+y !可以直接调用程序单元或module里的变量
    end function two
end function fun 

program strsub
      implicit none
      character(len=20)::str
      str="hello,world!"
      call sub(str)
      contains
              subroutine sub(strr)
                      implicit none
                      character(len=*) :: strr
                      write(*,*) trim(strr)
              end subroutine sub
end program strsub

program pro
      implicit none
      real :: array(10),total
      integer I
      array=(/(I,I=1,10)/)
      total=sum(array(2:3))
      write(*,*) total
end program pro

real  function sum(a)
     real::a(:)   !多维时a(:,:)，传入参数的下标变为1,2,3...,size(a,dim=n)，上限自动计算，下线也可指定
     !real::a(n)取出传过来的数组的前n个元素作为一个数组
     integer :: i
     sum=0
     do i=1,size(a,dim=1)
      sum=sum+a(i)
     end do
end function sum

module m_matradd
    implicit none
    contains
    subroutine matradd(m,n,A,B,C,lds)
    implicit none
    integer :: m,n,i,j,lds
    real:: A(*),B(*),C(*)

    !其实fortran直接 C=A+B 就可以
    !C(1:m*n)=A(1:m*n)+B(1:m*n)
    DO j=0,n-1
        DO i=1,m
            C(i+j*lds)=A(i+j*lds)+B(i+j*lds)
        end DO
    end DO
    end subroutine matradd
end module m_matrad

module typedef
      implicit none
      type :: student
              character(len=10) :: nickname
              integer :: num,score
      end type
end module typedef

program cndaqiang
      use typedef
!use module名 要在其他语句之前
      implicit none
      type(student)::xiaoming
      xiaoming%nickname="xiaoming"
      xiaoming%num=1
      xiaoming%score=95
      call sub(xiaoming)
end program

subroutine sub(who)
        use typedef
        implicit none
        type(student)::who
        write(*,*) who%nickname(:),who%num
end subroutine

module mod_fun
    !real :: x,y
contains
real function fun(test,x)
      implicit none
      interface !函数作为参数时，要用interface声明(解释)函数类型
      real function test(x)
      real ::x
      end function
      end interface
      real :: x
      fun=test(x)+x
end function fun      

real function test(x)
      implicit none
      real :: x
      test=x*x+x
end function test

end module mod_fun

program inter
    use mod_fun   !使用module导入的函数，不用声明
    implicit none
    real :: x,y
    x=3.0
    y=fun(test,x)
    write(*,*) y
end program inter

Integer , save :: var
Integer :: var = 0  !// 虽然没有书写 save ，但定义时初始化值，有具有 save 属性

!//输入参数，在子程序内部不允许改变  
Integer , Intent( IN ) :: input_arg   
!//输出参数，子程序返回前必须改变（对应实参不能是常数，也不能是表达式）
Integer , Intent( OUT ) :: output_arg 
!//中性参数
Integer , Intent( INOUT ) :: neuter_arg
Integer :: neuter_arg !// 未指定 Intent 则为中性
请注意：Intent 的检查是在编译时进行，而非运行时检查
建议对每一个虚参都指定 Intent 属性！

!//传值参数，只能作为输入参数。改变后不影响实参。  
Integer , value :: by_value_arg

请注意：除混编之外，一般不使用 value 属性

program op
      call opop(1)
      call opop()

contains
subroutine opop(a)
      integer,optional ::a   !a为可选参数
      if (present(a)) then
              write(*,*) "a=",a
      else
              write(*,*) "none"
      end if
end subroutine opop

end program op

call writeresult( Data = var , file = "res.txt" , size = 1000 ) 
call writeresult( var , 1000 , "res.txt") 

real function jifen(fun,down,up,step) result(y)

module 名称
implicit none
变量声明
!不能写任何执行语句
contains
函数定义
end module 名称

use module名称
!也可以使用module了内的某些，如下
use smartHome, only : tv , pc
!ONLY:使用名=>module中的名字
use smartHome, only : screen => tv , b ！使用并重命名

module m_init
      private
      public :: init1,init2
      contains
              subroutine init1()
                      write(*,*) "init1 begin"
              end subroutine init1
              subroutine init2()
                      write(*,*) "init2 gegin"
              end subroutine init2
end module m_init

Open( 子句 = 值 , 子句 = 值 , 子句 = 值 )
！它有二十多个子句，每一个都有各自的作用
!真正有必要的，只有两个：
Open( Unit = 通道号 , File = "文件名" )
Open( 通道号 , File = "文件名" )
!文件通道号，由程序员给定，一般用大于10的数字。
!10以下的数字由不同编译器预留（一些编译器用5，6表示标准输入输出）
!在 OPEN 语句中指定 STATUS=’SCRATCH’ 会打开一个名称形式为 tmp.FAAAxnnnnn 的文件，其中 nnnnn 用当前进程 ID 替换，AAA 是一个包含三个字符的字符串，x 是一个字母；AAA 和 x 可确保文件名唯一
!该文件在程序终止或执行 CLOSE 语句时被删除,如
open (is1,               form='formatted',status='scratch')

read(通道号,格式) 变量列表
read(字符串,格式) 变量列表 ！可将一行数据用字符纯的方式读入后，在处理字符串内的数据

11 12 13
21 22 23
31 32 33

program re
      implicit none
      real :: a,b,c,d,e,f
      integer :: i
      i=20
      open(i,file="file.txt")
      read(i,*) a,b,c,d !读到了1行多（即，第二行）
      read(i,*) e,f     !下一次从第三行读取
      write(*,*) a,b,c,d
      write(*,*) e,f
      close(i)
end program re      

   11.0000000       12.0000000       13.0000000       21.0000000
   31.0000000       32.0000000

open(unit=通道号,form="formatted"，access="Direct",RecL=64)	

      open(unit=i,file="file.bin",form="unformatted")
      write(i) a,str 

program re
      implicit none
      integer :: a,b,i
      character(len=5) :: str
      a=1
      b=2
      str="hello"
      i=20
      open(unit=i,file="file.bin",form="unformatted")
      write(i) a,str !4+5=9个数据
      write(i) b
      close(i)
      a=0
      b=0
      str="00000"
      open(unit=i,file="file.bin",form="unformatted")
      read(i) a,str  !读的时候，也要按相应数据长度
      read(i) b
      close(i)
      write(*,*) a,str,b
end program re

      open(unit=i,file="file.bin",form="unformatted",access="direct",recl=10)
      write(i,rec=1) a,str

open(unit=i,file="file.bin",form="unformatted",access="stream")
write(i) a,str
      
read(i,pos=5) !跳到第5个字节处开始读
inquire(i,pos=b)  !将当前位置返回到b

program str
      implicit none
      integer::filenum(5)
      integer::i,uid
      character(len=10) :: filename
      data filenum /1,12,123,1234,12345/
      uid=20
      do i=1,5
      write(filename,"(i6.5a4)") filenum(i),".txt" !把str当成文件来读写
      open(uid,file=filename)
      write(uid,*) filenum(i)
      close(uid)
      end do
end program str

' 00001.txt'  ' 00012.txt'  ' 00123.txt'  ' 01234.txt'  ' 12345.txt'

program now1
      implicit none
      character(len=255)  :: now,r
      integer::hh,mm,ss
      call date_and_time(time=now)   !获取系统时间函数
      read(now,"(i2i2i2)") hh,mm,ss
      write(*,"(a8,i2,a1,i2,a1,i2)") "now is: ",hh,":",mm,":",ss
end program now1

now is: 11:52:26

PROGRAM readdata
IMPLICIT NONE
INTEGER,PARAMETER   :: N=5
INTEGER     :: a(N)
a=100
CALL readarray(a,N,"data")
WRITE(*,*) "a:",a

CONTAINS
    SUBROUTINE readarray(a,N_,file)
    IMPLICIT NONE
    INTEGER :: N_,a(N_)
    CHARACTER(*)  :: file
    !Local
    INTEGER :: unit_io=666,N,i
    N=MIN(N_,UBOUND(a,1))

    OPEN(unit=unit_io,file=TRIM(file))
    DO i=1,N
    READ(unit_io,*,ERR=10,END=20) a(i)
    goto 30
    !读取错误执行goto 10
    !读取结束goto 20
    !正常读取goto 30,在此处直接写CYCLE也可以
    !结束行是没有内容的
    !Fortran的一行定义为: 有字母数字的意义行
    !多行的空白,逗号等会被忽略，不算行，不算读取位置
    !即　如果两行之间有很多回车空白，Fortran会直接跳过这些内容进行读取
    !即　Fortran中的结束行定义为:没有内容,或后面只有空格回车等无意义内容
    !即　若读到end, 就肯定没有读到任何数据,a(i)不会被改变
    10 WRITE(*,*) "ERR at:",i,"line" 
    goto 25
    20 WRITE(*,*) "END at:",i,"line" 
25    a(i:N)=0
    EXIT

    30 CYCLE
    ENDDO
    END SUBROUTINE readarray
END PROGRAM

cndaqiang@girl:~/code/test$ cat data ; echo "+++"; gfortran read.f90 ; ./a.out 
1
2
  

5

+++
 END at:           4 line
 a:           1           2           5           0           0

./environment.f90:116:          OPEN ( unit = stdout, file='/dev/null', status='unknown' )

         stdout_file = cla_get_output()
         if ( stdout_file /= ' ' ) then
            close(unit=6)
            open(unit=6,file=trim(stdout_file),form="formatted",
     &           position="rewind", action="write",status="unknown")
         end if

(python27) ~/code/TDQE/Fortran $ cat namelist.f90 
program namelist
INTEGER	:: a,b,c
NAMELIST  /NAME/ a,b
NAMELIST  /YES/ c
a=0
b=0
c=0
READ(*,NAME)
READ(*,YES)
write(*,*) a,b,c
END program namelist
(python27) ~/code/TDQE/Fortran $ cat data 
&NAME
	a=10
	b=9
/
&YES
	c=1
/
#注意输入文件最后要有一个空行，!开头的行也行，不然会报错
(python27) ~/code/TDQE/Fortran $ gfortran namelist.f90 
(python27) ~/code/TDQE/Fortran $ ./a.out < data 
          10           9           1

PROGRAM file
IMPLICIT NONE
INTEGER :: i,unit_io
unit_io=666
OPEN(unit=unit_io,file="data")
!读入当前行,并把位置下移一行
READ(unit_io,*) i
WRITE(*,*) i
!回到上一行
BACKSPACE(unit_io)
!
READ(unit_io,*) i
WRITE(*,*) i

ENDFILE(unit_io) !清除当前位置到最后的所有行,此处为>2行的所有数据
CLOSE(unit_io)

END PROGRAM

cndaqiang@girl:~/code/test$ cat data ; echo "++++" ; gfortran file.f90 ; ./a.out ;echo "---"; cat data 
1
2
3
4
++++
           1
           1
---
1
2

system("command"[,]状态)

call system("date",hh)

    INTEGER :: starttime,endtime
    call SYSTEM_CLOCK(starttime)
    代码部分
    call SYSTEM_CLOCK(endtime)
    walltime=(endtime-starttime)/1000

call sleep(n) !暂停n秒

在Fortran中主函数是没有参数的，所以要获取命令行参数需要额外调用其他的函数。
agrc=iargc()：
返回命令行参数的个数

call getarg(i,buffer)：
读取命令行的第i个参数，并将其存储到buffer中，其中命令本身是第0个参数

OPEN ( unit = stdout, file='/dev/null', status='unknown' )

program main
  implicit none
  character(len=10) :: time

  call get_environment_variable("t", time)
  write(6,*) time
end program main

export t=2010010100

(python37) cndaqiang@mommint:/tmp$ ./a.out
  0.99999996963214000      |             (2.30756021,1.47112763)

(python37) cndaqiang@mommint:~/code/octopus/CNQcode$ cat main.f90
program main
    IMPLICIT NONE
    interface
        subroutine cprinti( i)
                integer :: i
        end subroutine
    end interface

    integer :: i
    i=10
    call cprinti( i)
end program main

SUBROUTINE fprinti(i)
        IMPLICIT NONE
        INTEGER i
        write(*,*) "print i by fortran",i
END SUBROUTINE



(python37) cndaqiang@mommint:~/code/octopus/CNQcode$ cat csub.c
#include <stdio.h>
void cprinti_( int *i);
void fprinti_( int *i);

void cprinti_( int *i)
{
 *i=*i+1;
 printf("c Print i %10i\n",*i);
 fprinti_(i);
}

(python37) cndaqiang@mommint:~/code/octopus/CNQcode$ gfortran -c main.f90 -o main.o
(python37) cndaqiang@mommint:~/code/octopus/CNQcode$ gcc -c csub.c -o csub.o
(python37) cndaqiang@mommint:~/code/octopus/CNQcode$ gfortran -o main.x  main.o  csub.o
(python37) cndaqiang@mommint:~/code/octopus/CNQcode$ ./main.x
c Print i         11
 print i by fortran          11

gcc -DPACKAGE_NAME=\"qtool\" -DPACKAGE_TARNAME=\"qtool\" -DPACKAGE_VERSION=\"1.0\" -DPACKAGE_STRING=\"qtool\ 1.0\" -DPACKAGE_BUGREPORT=\"who@cndaqiang.ac.cn\" -DPACKAGE_URL=\"\" -DPACKAGE=\"qtool\" -DVERSION=\"1.0\" -I.     -g -O2 -MT csub.o -MD -MP -MF .deps/csub.Tpo -c -o csub.o csub.c
csub.c:11:6: error: ‘FC_FUNC_’ declared as function returning a function
 void FC_FUNC_(cfun,CFUNUN) (int *i)
      ^~~~~~~~
csub.c: In function ‘FC_FUNC_’:
csub.c:11:6: warning: type of ‘cfun’ defaults to ‘int’ [-Wimplicit-int]
csub.c:11:6: warning: type of ‘CFUNUN’ defaults to ‘int’ [-Wimplicit-int]
csub.c:13:3: error: ‘i’ undeclared (first use in this function)
  *i=*i+1;
   ^
csub.c:13:3: note: each undeclared identifier is reported only once for each function it appears in
Makefile:377: recipe for target 'csub.o' failed
make: *** [csub.o] Error 1

gcc -DPACKAGE_NAME=\"qtool\" -DPACKAGE_TARNAME=\"qtool\" -DPACKAGE_VERSION=\"1.0\" -DPACKAGE_STRING=\"qtool\ 1.0\" -DPACKAGE_BUGREPORT=\"who@cndaqiang.ac.cn\" -DPACKAGE_URL=\"\" -DPACKAGE=\"qtool\" -DVERSION=\"1.0\" -DFC_FUNC\(name,NAME\)=name\ ##\ _ -DFC_FUNC_\(name,NAME\)=name\ ##\ _ -I.     -g -O2 -MT csub.o -MD -MP -MF .deps/csub.Tpo -c -o csub.o csub.c

C:Print by cprinti_         11
C:Print by FC_FUNC         12

(python37) cndaqiang@mommint:~/code/octopus/CNQcode/automake/fortran$ sudo apt install makedepf90
(python37) cndaqiang@mommint:~/code/octopus/CNQcode/automake/fortran$ makedepf90 $(ls *.f90)
main.o : main.f90 m_mod.o
m_mod.o : m_mod.f90
qtool.o : qtool.f90
sub.o : sub.f90