能書き

プログラムが長くなれば長くなるほど保守作業は困難になります。
プログラムの一部を「サブルーチン」や「関数」として 本体から分離することで、より見やすく、手の加えやすい「応用の利く」プログラムになります。

program test
 !------------------------
 ! Fortran template
 !------------------------
 use bacs
 implicit none
 !--- main ---
  ...
 
 !--- internal procedures ---
 contains
 
 function f1(...)
  ...
 end function f1

 subroutine sub1(...)
  ...
 end subroutine sub1

end program

使い方は、こちらを復習して下さい。

定義：関数の定義

 contains

以下で、

 function 関数名([仮引数1],[仮引数2],...)
  型 :: 関数名
  [型 :: 仮引数名]
   関数名 = {式}
 end function

学習

『sin(x)』のような「関数」を自分で作ることができます。
実際の用途としては、 などがあります。 まずは簡単な例。

 real(kind=double) :: a,b
 
 a = 1.0d0
 b = 2.0d0
 print *, "a+b^2 =", myFunc(b,a)
 

 contains !--- internal procedures ---
 
  function myFunc(a,b)
   implicit none
   real(kind=double) :: a, b, myFunc
     myFunc = a*a +b
  end function
 
 end program

このように、 （ただしprogramの代わりにfunction） というのが基本的な考え方です。
functionに特有の性質として、 ことを覚えておきましょう。

学習：仮引数と局所変数

関数『function myFunc(a,b)』のかっこ中の変数『a,b』のことを、 「仮引数」と言います。
ここには、本体で使われたときにかっこの中に入っている値、 すなわち『b,a』の値（こちらを「実引数」と言う）が、「対応する順番で」入ります。
すなわち上のプログラムの実行結果は「a*a+b=3」ではなく

 a+b^2 =     5

となります。
ここで、 というのがポイントです。 このように、外部から直接見ることができず、 そのプログラム単位内だけで使われる変数のことを「局所（ローカル）変数」と言います。
変数名の競合に気を遣わなくて良いので、 そのままコピーペーストで他のプログラムに使い回すことができます。
逆に のですが、用途が限定される（普通の意味での「関数」ではなくなる）ので のが基本だと思って下さい。

問題：階乗の関数を作りなさい

そういうわけで、 「整数 n を受け取り、n! を実数で返す」関数を作ってみましょう。 >>解答

定義：サブルーチンの定義

 contains

以下で、

 subroutine サブルーチン名[(仮引数1,仮引数2,...)]
  [型, 引数授受特性 :: 仮引数名]
   {処理}
 end subroutine

＊引数授受特性
　『intent(in)』　入力引数（上書き禁止）
　『intent(out)』　出力引数（値読み込み禁止）
　『intent(inout)』　入出力引数（読み書き自由）

学習

関数が「いくつかの引数を受け取り、１つの値を出す」のに対し、
サブルーチンは「受け取った引数に対して処理を行う」もの（出力はいくつでも良い）です。
と考えたほうがいいかもしれません。
理屈の上では、すべての「処理」をサブルーチンに置き換えることが可能です。 実際にサブルーチンを使うべき場面としては、 などがあります。

例題

「２つの変数の値を入れ替える処理」をサブルーチンにします。

 real(kind=double) :: x, y
 
 x = zero
 y = one
 call swap(x,y)
 print *, "x =", x, ", y =", y
 call swap(x,y)
 print *, "x =", x, ", y =", y
 
 !--- internal procedures ---
 contains
 
  subroutine swap(a,b)
  implicit none
  real(kind=double), intent(inout) :: a, b
  real(kind=double) :: temp
    temp = a
    a    = b
    b    = temp
  end subroutine swap

 x = 1.0000000000, y = 0.0000000000
 x = 0.0000000000, y = 1.0000000000

この場合、 のがポイントです。

定義：モジュールの作成

本体とは別のファイル"モジュール名.f90"を作り、

 module モジュール名
 [use 他のモジュール]
 implicit none
 [変数の宣言]
 
 contains

　[subroutineやfunction]

 end module

という形式にする。
また、

モジュールのコンパイル

以下の３通りから、好きな方法でやると良い。
１．通常のコンパイル（堅実だがコンパイルに時間が掛かる）

$ ifort モジュール名.f90 本体.f90

２．分割コンパイル（一手間多いがコンパイルが速い）
はじめに一回だけ

$ ifort -c モジュール名.f90

$ ifort モジュール名.o 本体.f90

本体を書き換える度に（書き換えられていない）モジュールをコンパイルし直す必要がないのが利点。
３．make（本格的に計算するなら）
makefileという一種のスクリプトを書き、コンパイルする。

$ make

モジュールの数が多くなったらこれに頼るべき。（makeの説明）

学習：モジュールの役割

モジュールそのものはただの「器」に過ぎません。中に何を入れるかによって、その役割が変わってきます。 例えば以下のような使い方が出来ます。
・共通の定数をまとめて置いておく
・汎用的な（他のプログラムでも使える）ルーチンを独立させる
・汎用的な機能の集合体（パッケージ）
・プログラム本体から分離された関数、サブルーチンを、別ファイルにする
・共通の変数をまとめて置いておく

ある程度のプログラマになると、モジュールを使ってプログラムをうまく設計することが求められます。
が、皆さんは「サブルーチンの置き場所」くらいにとらえておけば十分です。

学習：副プログラムのパターン

実際に副プログラムを使う際の構成としては、
（１）本体の『contains』以下に、関数やサブルーチンを書き込んで使う（単一ファイル）
（２）新しくモジュールを作り、その『contains』以下に書き込む。本体でモジュールを『use』して使う（複数ファイル）
の２つが考えられます。まずは（１）で作り、必要な場合だけ（２）の形にするのが良いでしょう。

＊注意
古いFORTRANの慣習では、全ての関数、サブルーチンは「外部手続き」として単独で別ファイルにすることになっています。 が、Fortran90の仕様上、この方法は非推奨です（>>例）。 Fortran90（以降）世代の皆さんは、作ったサブルーチンを

実践：モジュール化の例

いつか見たプログラムをモジュールを使って書くと以下のようになる。
"hontai.f90"

program hontai
 use bacs
 use module1
 implicit none
 complex(kind=double), allocatable  :: Amat(:,:), Bmat(:,:), Cmat(:,:)
 integer :: m,n

  m = 2
  n = 3
  allocate(Amat(m,n), Bmat(m,n), Cmat(m,m))

  ! --- define matrices ---   注：ここの値は適当に決める。
  Amat(:,:) = cOne    ! cOne  = (1.0d0, 0.0d0) をAmatの全ての要素に代入
  Bmat(:,:) = cZero   ! cZero = (0.0d0, 0.0d0) をBmatの全ての要素に代入 
  Bmat(1,1:n) = img   ! img   = (0.0d0, 1.0d0) を１行目に入れる

  call matpro_ND(m,n,Amat,Bmat,Cmat)
 
  ! --- print C matrix ---   ! ループを使ってうまく表示してみよう。
  print *, "Real part of C matrix"
  print *, dble(Cmat)        ! 実数部分を(倍精度で)取り出す
  print *, "Imagnary part of C matrix"
  print *, aImag(Cmat)       ! 虚数部分を取り出す

 end program

"module1.f90"

program module1
 use bacs
 implicit none
 
 contains
  
  subroutine matpro_ND(m,n,A,B,C)
  implicit none
  integer,              intent(in)  :: m, n
  complex(kind=double), intent(in)  :: A(m,n), B(m,n)
  complex(kind=double), intent(out) :: C(m,m)
  integer :: j,k
   Cmat(:,:) = cZero
   do j=1,m
      do k=1,n
         Cmat(1:m,j) = Cmat(1:m,j) + Amat(1:m,k)*conjg(Bmat(j,k))
      end do
   end do
  end subroutine
  
 end module

今、サブルーチン『matpro_ND』は純粋に数学的な処理なので、本体側でどのような問題を扱っているかに依存しない。
こういう場合はモジュールとして分離するのが望ましい。

謝辞

Fortran実用編はここまでです。
プログラミング言語としてのFortranは、ほぼ学び終えたと考えて良いでしょう。 あとは実際に自分の手でプログラムを組んでみて、技術としてのプログラミングを学ぶだけです。
わからないことが出てきたら、ネットで調べるなり人に聞くなりしましょう。 また、私（著者）に質問すれば、その内容がこの講義ノートにも反映されることになります。遠慮無く質問して下さい。

ちなみに・・・プロの計算屋を目指すなら、より高度な技法を身につける必要があります。
もし希望するのであれば、個人的に修行をつけます。ご相談下さい。