dc_date_generic.f90

Go to the documentation of this file.

! -*- mode: f90; coding: utf-8 -*-
!-----------------------------------------------------------------------
! Copyright (c) 2000-2026 Gtool Development Group. All rights reserved.
!-----------------------------------------------------------------------
!>
!> @author    Yasuhiro MORIKAWA, Eizi TOYODA
!> @copyright Copyright (C) GFD Dennou Club, 2000-2026. All rights reserved. <br/>
!>            License is BSD-2-Clause. see [COPYRIGHT](@ref COPYRIGHT) in detail
!>
!> @en
!> @brief Interface declarations for procedures provided from dc_date
!> @details
!> This module provides interface declarations for procedures in dc_date.
!> See dc_date for module overview.
!>
!> @section date_generic_procedures Procedures List
!>
!> The following procedures operate on DC_DATETIME or DC_DIFFTIME
!> derived types (which store date/time information).
!>
!> | Procedure            | Description                                      |
!> |----------------------|--------------------------------------------------|
!> | DCDateTimeCreate     | Initialize DC_DATETIME type variable             |
!> | DCDiffTimeCreate     | Initialize DC_DIFFTIME type variable             |
!> | assignment(=)        | Initialize DC_DATETIME/DC_DIFFTIME variables     |
!> | Eval                 | Get individual date/time components              |
!> | toChar               | Convert date/time to character string            |
!> | EvalDay              | Get as number of days (real type)                |
!> | EvalHour             | Get as number of hours (real type)               |
!> | EvalMin              | Get as number of minutes (real type)             |
!> | EvalSec              | Get as number of seconds (real type)             |
!> | EvalNondim           | Get as nondimensional time (real type)           |
!> | EvalByUnit           | Get in specified unit (day/hour/min/sec)         |
!> | operator(+)          | Addition (DC_DATETIME and DC_DIFFTIME types)     |
!> | operator(-)          | Subtraction (DC_DATETIME and DC_DIFFTIME types)  |
!> | operator(*)          | Multiplication (DC_DIFFTIME and numeric types)   |
!> | operator(/)          | Division (DC_DIFFTIME and numeric types)         |
!> | mod                  | Remainder (between DC_DIFFTIME types)            |
!> | operator(==)         | Comparison (between DC_DATETIME types)           |
!> | operator(>)          | Comparison (between DC_DATETIME types)           |
!> | operator(>=)         | Comparison (between DC_DATETIME types)           |
!> | operator(<)          | Comparison (between DC_DATETIME types)           |
!> | operator(<=)         | Comparison (between DC_DATETIME types)           |
!> | max                  | Return larger value                              |
!> | min                  | Return smaller value                             |
!> | SetZone              | Change timezone                                  |
!> | DCDateTimePutLine    | Print DC_DATETIME variable information           |
!> | DCDiffTimePutLine    | Print DC_DIFFTIME variable information           |
!>
!> The following procedures modify internal variables in dc_date_types:
!>
!> | Procedure      | Description                                        |
!> |----------------|----------------------------------------------------|
!> | SetCaltype     | Change default calendar type                       |
!> | SetSecOfDay    | Change default seconds per day                     |
!>
!> Other procedures:
!>
!> | Procedure      | Description                                        |
!> |----------------|----------------------------------------------------|
!> | ValidCaltype   | Check if calendar type is valid                    |
!> | ValidZone      | Check if timezone is valid                         |
!> | ZoneToDiff     | Convert timezone to DC_DIFFTIME variable           |
!> | ParseTimeUnits | Parse time unit and return unit symbol             |
!>
!> @section date_generic_usage Usage
!>
!> @subsection date_generic_current Display Current Time
!>
!> When DCDateTimeCreate subroutine is used on a DC_DATETIME type variable,
!> the time is set. If year/month/day are not specified, current time is set.
!> The set time can be converted to character type with toChar.
!> See dc_string::Printf for Printf subroutine details.
!>
!> @code{.f90}
!> program dc_date_sample1
!>   use dc_string, only: Printf
!>   use dc_date, only: DC_DATETIME, DCDateTimeCreate, toChar
!>   implicit none
!>   type(DC_DATETIME) :: time
!>
!>   call DCDateTimeCreate( time = time ) ! (out)
!>   call Printf( fmt = 'current date and time is %c', c1 = trim( toChar(time) ) )
!> end program dc_date_sample1
!> @endcode
!>
!> @subsection date_generic_add Adding Date/Time Information
!>
!> DC_DIFFTIME type variables express time differences. In the example below,
!> variable *diff* is prepared and set to 25 days + 12 hours + 50 minutes
!> using Create subroutine. By adding DC_DATETIME variable *time_before*
!> and *diff* with operator(+), we get *time_after* which is 25 days +
!> 12 hours + 50 minutes ahead of *time_before*.
!>
!> @code{.f90}
!> program dc_date_sample2
!>   use dc_types, only: DP
!>   use dc_string, only: Printf
!>   use dc_date, only: DC_DATETIME, DC_DIFFTIME, &
!>     & DCDateTimeCreate, DCDiffTimeCreate, toChar, operator(+)
!>   implicit none
!>   type(DC_DATETIME) :: time_before, time_after
!>   type(DC_DIFFTIME) :: diff
!>
!>   call DCDateTimeCreate( time = time_before, & ! (out)
!>     & year = 2006, mon = 6,  day = 10, &       ! (in)
!>     & hour = 14,   min = 15, sec = 0.0_DP )    ! (in)
!>   call DCDiffTimeCreate( diff = diff, &        ! (out)
!>     & day = 25, hour = 12, min = 50)           ! (in)
!>
!>   time_after = time_before + diff
!>
!>   call Printf( fmt = '%c + %c = %c', &
!>     & c1 = trim( toChar(time_before) ), c2 = trim( toChar(diff) ), &
!>     & c3 = trim( toChar(time_after) ) )
!> end program dc_date_sample2
!> @endcode
!>
!> @subsection date_generic_loop Application to Time Integration Loop
!>
!> Below is an example program solving dA/dt = -αA (initial value 1, α=0.0001)
!> up to t = 12 (hours) using forward difference. By using DC_DIFFTIME for
!> Δt, data output interval, and calculation time, loop termination and
!> time comparison for data output become easy.
!>
!> @code{.f90}
!> program dc_date_sample3
!>   use dc_types, only: DP
!>   use dc_date, only: DC_DIFFTIME, &
!>     & DCDiffTimeCreate, EvalSec, EvalByUnit, mod, &
!>     & operator(*), operator(==), operator(>)
!>   implicit none
!>   real(DP)                :: func_a = 1.0d0    ! Initial value of function A
!>   real(DP), parameter     :: alph   = 0.0001d0 ! Coefficient α
!>   character(*), parameter :: out_unit = 'hour' ! Unit for output time
!>   type(DC_DIFFTIME):: DelTimef, intervalf, calctimef
!>   integer :: i
!> continue
!>   call DCDiffTimeCreate( &            !       Δt = 5.0 (sec)
!>     & diff = DelTimef, &              ! (out)
!>     & value = 5.0_DP, unit = 'sec')   ! (in)
!>   call DCDiffTimeCreate( &            !       Data output interval = 1.0 (min)
!>     & diff = intervalf, &             ! (out)
!>     & value = 1.0_DP, unit = 'min')   ! (in)
!>   call DCDiffTimeCreate( &            !       Calculation time = 12.0 (hour)
!>     & diff = calctimef, &             ! (out)
!>     & value = 12.0_DP, unit = 'hour') ! (in)
!>
!>   open( 10, file='dc_date_sample.dat' )
!>   write(10,'(A,A,A)') '#  ', out_unit, '                value'
!>
!>   i = 1
!>   do
!>     if (DelTimef * i > calctimef) exit    ! Exit when past calculation time
!>
!>     ! A_(n+1) = (1 - αΔt) * A_(n)
!>     func_a = (1.0 - alph * EvalSec(DelTimef)) * func_a
!>
!>     ! Output data every intervalf (1 min)
!>     if (mod(DelTimef * i, intervalf) == 0) then
!>       write(10,*) ' ', EvalByUnit( DelTimef * i, out_unit ), func_a
!>     end if
!>     i = i + 1
!>   end do
!> end program dc_date_sample3
!> @endcode
!>
!> @enden
!>
!> @ja
!> @brief dc_date より提供される手続の引用仕様宣言
!> @details
!> このモジュールは dc_date の手続きの引用仕様を提供します.
!> モジュールの概要については dc_date を参照ください.
!>
!> @section date_generic_procedures_ja 手続一覧
!>
!> 以下の手続きは DC_DATETIME または DC_DIFFTIME 派生型
!> (日時・時刻に関する情報を格納) を対象とします.
!>
!> | 手続名               | 説明                                             |
!> |----------------------|--------------------------------------------------|
!> | DCDateTimeCreate     | DC_DATETIME 型変数の初期設定                     |
!> | DCDiffTimeCreate     | DC_DIFFTIME 型変数の初期設定                     |
!> | assignment(=)        | DC_DATETIME/DC_DIFFTIME 変数の初期設定           |
!> | Eval                 | 日時・時刻情報を個別に取得                       |
!> | toChar               | 日時・時刻情報を文字型変数へ変換                 |
!> | EvalDay              | 日数 (実数型) に換算して取得                     |
!> | EvalHour             | 時間 (実数型) に換算して取得                     |
!> | EvalMin              | 分 (実数型) に換算して取得                       |
!> | EvalSec              | 秒 (実数型) に換算して取得                       |
!> | EvalNondim           | 無次元時間 (実数型) に換算して取得               |
!> | EvalByUnit           | 単位を指定し、日・時・分・秒のいずれかに換算     |
!> | operator(+)          | 加算 (DC_DATETIME/DC_DIFFTIME 型同士)            |
!> | operator(-)          | 減算 (DC_DATETIME/DC_DIFFTIME 型同士)            |
!> | operator(*)          | 乗算 (DC_DIFFTIME 型と数値型)                    |
!> | operator(/)          | 除算 (DC_DIFFTIME 型と数値型)                    |
!> | mod                  | 余り (DC_DIFFTIME 型同士)                        |
!> | operator(==)         | 比較 (DC_DATETIME 型同士)                        |
!> | operator(>)          | 比較 (DC_DATETIME 型同士)                        |
!> | operator(>=)         | 比較 (DC_DATETIME 型同士)                        |
!> | operator(<)          | 比較 (DC_DATETIME 型同士)                        |
!> | operator(<=)         | 比較 (DC_DATETIME 型同士)                        |
!> | max                  | 大きい値を返す                                   |
!> | min                  | 小さい値を返す                                   |
!> | SetZone              | タイムゾーンを変更                               |
!> | DCDateTimePutLine    | DC_DATETIME 変数の情報を印字                     |
!> | DCDiffTimePutLine    | DC_DIFFTIME 変数の情報を印字                     |
!>
!> 以下の手続きは dc_date_types 内部の変数を変更します:
!>
!> | 手続名         | 説明                                             |
!> |----------------|--------------------------------------------------|
!> | SetCaltype     | 暦法のデフォルトを変更                           |
!> | SetSecOfDay    | 1 日の秒数のデフォルトを変更                     |
!>
!> その他の手続き:
!>
!> | 手続名         | 説明                                             |
!> |----------------|--------------------------------------------------|
!> | ValidCaltype   | 暦法が有効なものかをチェック                     |
!> | ValidZone      | タイムゾーンとして有効かをチェック               |
!> | ZoneToDiff     | タイムゾーンを DC_DIFFTIME 変数へと変換          |
!> | ParseTimeUnits | 時間の単位を解析し、単位のシンボルを返す         |
!>
!> @section date_generic_usage_ja 使用方法
!>
!> @subsection date_generic_current_ja 現在時刻の表示
!>
!> DC_DATETIME 型の変数に DCDateTimeCreate サブルーチンを用いると
!> 時刻が設定されます. 特に年月日を指定しないと現在時刻が設定されます.
!> 設定された時刻は toChar によって文字型変数へと変換できます.
!> Printf サブルーチンについては dc_string::Printf を参照ください.
!>
!> @code{.f90}
!> program dc_date_sample1
!>   use dc_string, only: Printf
!>   use dc_date, only: DC_DATETIME, DCDateTimeCreate, toChar
!>   implicit none
!>   type(DC_DATETIME) :: time
!>
!>   call DCDateTimeCreate( time = time ) ! (out)
!>   call Printf( fmt = 'current date and time is %c', c1 = trim( toChar(time) ) )
!> end program dc_date_sample1
!> @endcode
!>
!> @subsection date_generic_add_ja 日時・時刻情報の加算
!>
!> DC_DIFFTIME 型の変数は日時差を表現します. 下記の例では、
!> 日時差を表現するための変数として *diff* を用意し、
!> Create サブルーチンで 25 日 + 12 時間 + 50 分の日時差を設定しています.
!> DC_DATETIME 型の変数 *time_before* と *diff* とを operator(+) によって
!> 加算することで *time_before* から 25 日 + 12 時間 + 50 分を
!> 進めた日時 *time_after* を取得しています.
!>
!> @code{.f90}
!> program dc_date_sample2
!>   use dc_types, only: DP
!>   use dc_string, only: Printf
!>   use dc_date, only: DC_DATETIME, DC_DIFFTIME, &
!>     & DCDateTimeCreate, DCDiffTimeCreate, toChar, operator(+)
!>   implicit none
!>   type(DC_DATETIME) :: time_before, time_after
!>   type(DC_DIFFTIME) :: diff
!>
!>   call DCDateTimeCreate( time = time_before, & ! (out)
!>     & year = 2006, mon = 6,  day = 10, &       ! (in)
!>     & hour = 14,   min = 15, sec = 0.0_DP )    ! (in)
!>   call DCDiffTimeCreate( diff = diff, &        ! (out)
!>     & day = 25, hour = 12, min = 50)           ! (in)
!>
!>   time_after = time_before + diff
!>
!>   call Printf( fmt = '%c + %c = %c', &
!>     & c1 = trim( toChar(time_before) ), c2 = trim( toChar(diff) ), &
!>     & c3 = trim( toChar(time_after) ) )
!> end program dc_date_sample2
!> @endcode
!>
!> @subsection date_generic_loop_ja 時間積分のループへの応用
!>
!> 以下は dA/dt = -αA (初期値 1, α=0.0001) を t = 12 (時間)
!> まで解くプログラムの例です. 時間積分には前進差分を用いています.
!> Δt、データの出力間隔、計算時間に DC_DIFFTIME を用いることで、
!> ループの終了処理やデータ出力の際の時刻の比較が容易となります.
!>
!> @code{.f90}
!> program dc_date_sample3
!>   use dc_types, only: DP
!>   use dc_date, only: DC_DIFFTIME, &
!>     & DCDiffTimeCreate, EvalSec, EvalByUnit, mod, &
!>     & operator(*), operator(==), operator(>)
!>   implicit none
!>   real(DP)                :: func_a = 1.0d0    ! 関数 A の初期値
!>   real(DP), parameter     :: alph   = 0.0001d0 ! 係数 α
!>   character(*), parameter :: out_unit = 'hour' ! 出力される時刻の単位
!>   type(DC_DIFFTIME):: DelTimef, intervalf, calctimef
!>   integer :: i
!> continue
!>   call DCDiffTimeCreate( &            !       Δt = 5.0 (秒)
!>     & diff = DelTimef, &              ! (out)
!>     & value = 5.0_DP, unit = 'sec')   ! (in)
!>   call DCDiffTimeCreate( &            !       データ出力間隔 = 1.0 (分)
!>     & diff = intervalf, &             ! (out)
!>     & value = 1.0_DP, unit = 'min')   ! (in)
!>   call DCDiffTimeCreate( &            !       計算時間 = 12.0 (時間)
!>     & diff = calctimef, &             ! (out)
!>     & value = 12.0_DP, unit = 'hour') ! (in)
!>
!>   open( 10, file='dc_date_sample.dat' )
!>   write(10,'(A,A,A)') '#  ', out_unit, '                value'
!>
!>   i = 1
!>   do
!>     if (DelTimef * i > calctimef) exit    ! 計算時間を過ぎたら終了
!>
!>     ! A_(n+1) = (1 - αΔt) * A_(n)
!>     func_a = (1.0 - alph * EvalSec(DelTimef)) * func_a
!>
!>     ! intervalf (1 分) 毎にデータを出力
!>     if (mod(DelTimef * i, intervalf) == 0) then
!>       write(10,*) ' ', EvalByUnit( DelTimef * i, out_unit ), func_a
!>     end if
!>     i = i + 1
!>   end do
!> end program dc_date_sample3
!> @endcode
!>
!> @endja
!>
module dc_date_generic
 
  use dc_date_types, only: dc_datetime, dc_difftime
  use dc_types, only: dp, string, token
  use dc_present, only: present_and_not_empty
 
  implicit none
 
  private
  public:: dcdatetimecreate, dcdifftimecreate
  public:: dcdatetimeputline, dcdifftimeputline
  public:: eval
  public:: setcaltype, setzone, setsecofday
  public:: validcaltype, validzone, zonetodiff, parsetimeunits
 
  public:: assignment(=)
  public:: mod, operator(/), operator(-), operator(+), operator(*)
  public:: operator(<), operator(>), operator(>=), operator(<=)
  public:: operator(==), max, min
  public:: tochar, tocharcal
  public:: evalday, evalhour, evalmin, evalsec, evalnondim, evalbyunit
  public:: evalsclsec
 
  public:: create, putline
                    ! 後方互換用
                    ! For backward compatibility
 
  interface dcdatetimecreate
    subroutine dcdatetimecreate1(time, &
      & year, mon, day, hour, min, sec, &
      & zone, zone_hour, zone_min, caltype, caltype_str, day_seconds, &
      & sclyear, sclmon, sclday, sclsec, err) !:doc-priority 40:
      use dc_types, only: dp
      use dc_date_types, only: dc_datetime
      use dc_scaledsec, only: dc_scaled_sec
      type(dc_datetime), intent(out):: time
      integer, intent(in), optional:: year, mon, day, hour, min
      real(DP),intent(in), optional:: sec, day_seconds
      character(*), intent(in), optional :: zone
      integer, intent(in), optional :: zone_hour
      integer, intent(in), optional :: zone_min
      integer, intent(in), optional:: caltype
      character(*), intent(in), optional:: caltype_str
      type(dc_scaled_sec), intent(in), optional:: sclyear, sclmon, sclday, sclsec
      logical, intent(out), optional:: err
    end subroutine dcdatetimecreate1
  end interface
 
  interface dcdifftimecreate
    subroutine dcdifftimecreate1(diff, &
      & year, mon, day, hour, min, sec, day_seconds, nondim, &
      & sclyear, sclmon, sclday, sclsec ) !:doc-priority 60:
      use dc_types, only: dp
      use dc_date_types, only: dc_difftime
      use dc_scaledsec, only: dc_scaled_sec
      type(dc_difftime), intent(out) :: diff
      integer, intent(in), optional:: year, mon, day, hour, min
      real(DP),intent(in), optional:: sec, day_seconds, nondim
      type(dc_scaled_sec), intent(in), optional:: sclyear, sclmon, sclday, sclsec
    end subroutine dcdifftimecreate1
 
    subroutine dcdifftimecreate2d(diff, value, unit, unit_symbol, err) !:doc-priority 70:
      use dc_types, only: dp
      use dc_date_types, only: dc_difftime
      type(dc_difftime), intent(out) :: diff
      real(DP), intent(in) :: value
      character(*), intent(in) :: unit
      integer, intent(in), optional :: unit_symbol
      logical, intent(out), optional :: err
    end subroutine dcdifftimecreate2d
 
    subroutine dcdifftimecreate2r(diff, value, unit, unit_symbol, err) !:doc-priority 80:
      use dc_date_types, only: dc_difftime
      type(dc_difftime), intent(out) :: diff
      real, intent(in) :: value
      character(*), intent(in) :: unit
      integer, intent(in), optional :: unit_symbol
      logical, intent(out), optional :: err
    end subroutine dcdifftimecreate2r
 
    subroutine dcdifftimecreate2i(diff, value, unit, unit_symbol, err) !:doc-priority 90:
      use dc_date_types, only: dc_difftime
      type(dc_difftime), intent(out) :: diff
      integer, intent(in) :: value
      character(*), intent(in) :: unit
      integer, intent(in), optional :: unit_symbol
      logical, intent(out), optional :: err
    end subroutine dcdifftimecreate2i
 
  end interface
 
  interface dcdatetimeputline
    subroutine dcdatetimeputline(time, unit, indent)
      use dc_date_types, only: dc_datetime
      type(dc_datetime), intent(in) :: time
      integer, intent(in), optional :: unit
      character(*), intent(in), optional:: indent
    end subroutine dcdatetimeputline
  end interface
 
  interface dcdifftimeputline
    subroutine dcdifftimeputline(diff, unit, indent)
      use dc_date_types, only: dc_difftime
      type(dc_difftime), intent(in) :: diff
      integer, intent(in), optional :: unit
      character(*), intent(in), optional:: indent
    end subroutine dcdifftimeputline
  end interface
 
  interface assignment(=)
 
    subroutine dcdatetimecreatei(time, sec) !:doc-priority 20:
      use dc_date_types, only: dc_datetime
      type(dc_datetime), intent(out):: time
      integer, intent(in):: sec
    end subroutine dcdatetimecreatei
 
    subroutine dcdatetimecreater(time, sec) !:doc-priority 30:
      use dc_date_types, only: dc_datetime
      type(dc_datetime), intent(out):: time
      real, intent(in):: sec
    end subroutine dcdatetimecreater
 
    subroutine dcdatetimecreated(time, sec) !:doc-priority 40:
      use dc_types, only: dp
      use dc_date_types, only: dc_datetime
      type(dc_datetime), intent(out):: time
      real(DP), intent(in):: sec
    end subroutine dcdatetimecreated
 
    subroutine dcdifftimecreatei(diff, sec) !:doc-priority 60:
      use dc_date_types, only: dc_difftime
      type(dc_difftime), intent(out):: diff
      integer, intent(in):: sec
    end subroutine dcdifftimecreatei
 
    subroutine dcdifftimecreater(diff, sec) !:doc-priority 70:
      use dc_date_types, only: dc_difftime
      type(dc_difftime), intent(out):: diff
      real, intent(in):: sec
    end subroutine dcdifftimecreater
 
    subroutine dcdifftimecreated(diff, sec) !:doc-priority 80:
      use dc_types, only: dp
      use dc_date_types, only: dc_difftime
      type(dc_difftime), intent(out):: diff
      real(DP), intent(in):: sec
    end subroutine dcdifftimecreated
 
!!$    subroutine DCDateLetFC(diff, string)
!!$      use dc_date_types, only: DC_DIFFTIME
!!$      type(DC_DIFFTIME), intent(out):: diff
!!$      character(len = *), intent(in):: string
!!$    end subroutine DCDateLetFC
!!$
!!$    subroutine DCDateLetTC(time, string)
!!$      use dc_date_types, only: DC_DATETIME
!!$      type(DC_DATETIME), intent(out):: time
!!$      character(len = *), intent(in):: string
!!$    end subroutine DCDateLetTC
 
  end interface
 
  interface setcaltype
    subroutine dcdatetimesetcaltype(caltype)
      integer, intent(in):: caltype
    end subroutine dcdatetimesetcaltype
  end interface
 
  interface setsecofday
    subroutine dcdatetimesetsecofday(sec)
      use dc_types, only: dp
      real(DP), intent(in):: sec
    end subroutine dcdatetimesetsecofday
  end interface
 
  interface validcaltype
    function dcdatetimevalidcaltype(caltype) result(result)
      integer, intent(in):: caltype
      logical:: result
    end function dcdatetimevalidcaltype
  end interface
 
  interface validzone
    function dcdatetimevalidzone(zone) result(result)
      character(*), intent(in):: zone
      logical:: result
    end function dcdatetimevalidzone
  end interface
 
  interface zonetodiff
    function dcdatetimezonetodiff(zone) result(diff)
      use dc_date_types, only: dc_difftime
      type(dc_difftime):: diff
      character(*), intent(in):: zone
    end function dcdatetimezonetodiff
  end interface
 
  interface parsetimeunits
    function dcdatetimeparseunits(str) result(symbol)
      character(*), intent(in):: str
      integer:: symbol
    end function dcdatetimeparseunits
  end interface
 
  interface setzone
    subroutine dcdatetimesetzone(time, zone, err)
      use dc_date_types, only: dc_datetime
      type(dc_datetime), intent(inout):: time
      character(*), intent(in):: zone
      logical, intent(out), optional:: err
    end subroutine dcdatetimesetzone
  end interface
 
 
  interface eval
 
    subroutine dcdatetimeeval1(time, year, mon, day, hour, min, &
      & sec, caltype, zone, sclyear, sclmon, sclday, sclsec)  !:doc-priority 40:
      use dc_types, only: dp
      use dc_date_types, only: dc_datetime
      use dc_scaledsec, only: dc_scaled_sec
      type(dc_datetime), intent(in):: time
      integer, intent(out), optional:: year, mon, day, hour, min, caltype
      real(DP), intent(out), optional:: sec
      character(*), intent(out), optional:: zone
      type(dc_scaled_sec), intent(out), optional:: sclyear, sclmon, sclday, sclsec
    end subroutine dcdatetimeeval1
 
!!$    subroutine DCDateTimeEval0(time, mon, day, sec)
!!$      use dc_date_types, only: DC_DATETIME
!!$      use dc_types,      only: DP
!!$      type(DC_DATETIME), intent(in):: time
!!$      integer, intent(out):: mon, day
!!$      real(DP), intent(out):: sec
!!$    end subroutine DCDateTimeEval0
 
    subroutine dcdifftimeeval1(diff, &
      & year, mon, day, hour, min, sec, nondim, &
      & sclyear, sclmon, sclday, sclsec, sclnondim, err)  !:doc-priority 60:
      use dc_types, only: dp
      use dc_date_types, only: dc_difftime
      use dc_scaledsec, only: dc_scaled_sec
      type(dc_difftime), intent(in):: diff
      integer, intent(out), optional:: year, mon, day, hour, min
      real(DP), intent(out), optional:: sec, nondim
      type(dc_scaled_sec), intent(out), optional:: sclyear, sclmon, sclday, sclsec, sclnondim
      logical, intent(out), optional :: err
    end subroutine dcdifftimeeval1
 
  end interface
 
  interface evalday
    function dcdatetimeevalday(time) result(result)  !:doc-priority 40:
      use dc_types, only: dp
      use dc_date_types, only: dc_datetime
      real(dp):: result
      type(dc_datetime), intent(in):: time
    end function dcdatetimeevalday
 
    function dcdifftimeevalday(diff) result(result)  !:doc-priority 60:
      use dc_types, only: dp
      use dc_date_types, only: dc_difftime
      real(dp):: result
      type(dc_difftime), intent(in):: diff
    end function dcdifftimeevalday
  end interface
 
  interface evalhour
    function dcdatetimeevalhour(time) result(result) !:doc-priority 40:
      use dc_types, only: dp
      use dc_date_types, only: dc_datetime
      real(dp):: result
      type(dc_datetime), intent(in):: time
    end function dcdatetimeevalhour
 
    function dcdifftimeevalhour(diff) result(result) !:doc-priority 60:
      use dc_types, only: dp
      use dc_date_types, only: dc_difftime
      real(dp):: result
      type(dc_difftime), intent(in):: diff
    end function dcdifftimeevalhour
  end interface
 
  interface evalmin
    function dcdatetimeevalmin(time) result(result) !:doc-priority 40:
      use dc_types, only: dp
      use dc_date_types, only: dc_datetime
      real(dp):: result
      type(dc_datetime), intent(in):: time
    end function dcdatetimeevalmin
 
    function dcdifftimeevalmin(diff) result(result) !:doc-priority 60:
      use dc_types, only: dp
      use dc_date_types, only: dc_difftime
      real(dp):: result
      type(dc_difftime), intent(in):: diff
    end function dcdifftimeevalmin
  end interface
 
  interface evalsec
    function dcdatetimeevalsec(time) result(result) !:doc-priority 40:
      use dc_types, only: dp
      use dc_date_types, only: dc_datetime
      real(dp):: result
      type(dc_datetime), intent(in):: time
    end function dcdatetimeevalsec
 
    function dcdifftimeevalsec(diff) result(result) !:doc-priority 60:
      use dc_types, only: dp
      use dc_date_types, only: dc_difftime
      real(dp):: result
      type(dc_difftime), intent(in):: diff
    end function dcdifftimeevalsec
  end interface
 
  interface evalnondim
    function dcdifftimeevalnondim(diff) result(result)
      use dc_types, only: dp
      use dc_date_types, only: dc_difftime
      real(dp):: result
      type(dc_difftime), intent(in):: diff
    end function dcdifftimeevalnondim
  end interface
 
  interface evalsclsec
    function dcdatetimeevalsclsec(time) result(result) !:doc-priority 40:
      use dc_date_types, only: dc_datetime
      use dc_scaledsec, only: dc_scaled_sec
      type(dc_scaled_sec):: result
      type(dc_datetime), intent(in):: time
    end function dcdatetimeevalsclsec
 
    function dcdifftimeevalsclsec(diff) result(result) !:doc-priority 60:
      use dc_date_types, only: dc_difftime
      use dc_scaledsec, only: dc_scaled_sec
      type(dc_scaled_sec):: result
      type(dc_difftime), intent(in):: diff
    end function dcdifftimeevalsclsec
  end interface
 
  interface evalbyunit
 
    function dcdatetimeevalbyunit(time, unit, unit_symbol) result(result)
      use dc_types, only: dp, token
      use dc_date_types, only: dc_datetime
      real(dp):: result
      type(dc_datetime), intent(in):: time
      character(*), intent(in), optional:: unit
      integer, intent(in), optional:: unit_symbol
    end function dcdatetimeevalbyunit
 
    function dcdifftimeevalbyunit(diff, unit, unit_symbol) result(result)
      use dc_types, only: dp, token
      use dc_date_types, only: dc_difftime
      real(dp):: result
      type(dc_difftime), intent(in):: diff
      character(*), intent(in), optional:: unit
      integer, intent(in), optional:: unit_symbol
    end function dcdifftimeevalbyunit
  end interface
 
 
 
  interface tochar
    function dcdatetimetochar(time) result(result) !:doc-priority 40:
      use dc_types, only: string
      use dc_date_types, only: dc_datetime
      character(STRING) :: result
      type(dc_datetime), intent(in):: time
    end function dcdatetimetochar
 
    function dcdifftimetochar(diff) result(result) !:doc-priority 60:
      use dc_types, only: string
      use dc_date_types, only: dc_difftime
      character(STRING) :: result
      type(dc_difftime), intent(in):: diff
    end function dcdifftimetochar
  end interface
 
  interface tocharcal
    function dcdatetimetocharcal(time, upcase) result(result)
      use dc_types, only: token
      use dc_date_types, only: dc_datetime
      character(TOKEN) :: result
      type(dc_datetime), intent(in):: time
      logical, intent(in), optional:: upcase
    end function dcdatetimetocharcal
  end interface
 
  interface operator(+)
    type(dc_datetime) function dcdatetime_add_ft(diff, time) result(result)
      use dc_date_types, only: dc_datetime, dc_difftime
      type(dc_difftime), intent(in):: diff
      type(dc_datetime), intent(in):: time
    end function dcdatetime_add_ft
 
    type(dc_datetime) function dcdatetime_add_tf(time, diff) result(result)
      use dc_date_types, only: dc_datetime, dc_difftime
      type(dc_datetime), intent(in):: time
      type(dc_difftime), intent(in):: diff
    end function dcdatetime_add_tf
 
    type(dc_difftime) function dcdatetime_add_ff(diff1, diff2) result(result)
      use dc_date_types, only: dc_datetime, dc_difftime
      type(dc_difftime), intent(in):: diff1, diff2
    end function dcdatetime_add_ff
 
    type(dc_difftime) function dcdatetime_add_fd(diff, sec) result(result)
      use dc_date_types, only: dc_datetime, dc_difftime
      use dc_types, only: dp
      type(dc_difftime), intent(in):: diff
      real(dp), intent(in):: sec
    end function dcdatetime_add_fd
 
    type(dc_difftime) function dcdatetime_add_fr(diff, sec) result(result)
      use dc_date_types, only: dc_datetime, dc_difftime
      type(dc_difftime), intent(in):: diff
      real, intent(in):: sec
    end function dcdatetime_add_fr
 
    type(dc_difftime) function dcdatetime_add_fi(diff, sec) result(result)
      use dc_date_types, only: dc_datetime, dc_difftime
      type(dc_difftime), intent(in):: diff
      integer, intent(in):: sec
    end function dcdatetime_add_fi
  end interface
 
  interface operator(-)
    type(dc_datetime) function dcdatetime_sub_tf(time, diff) result(result) !:doc-priority 40:
      use dc_date_types, only: dc_datetime, dc_difftime
      type(dc_datetime), intent(in):: time
      type(dc_difftime), intent(in):: diff
    end function dcdatetime_sub_tf
 
    type(dc_difftime) function dcdatetime_sub_tt(time1, time2) result(result)
      use dc_date_types, only: dc_datetime, dc_difftime
      type(dc_datetime), intent(in):: time1, time2
    end function dcdatetime_sub_tt
 
    type(dc_difftime) function dcdatetime_sub_ff(diff1, diff2) result(result)
      use dc_date_types, only: dc_datetime, dc_difftime
      type(dc_difftime), intent(in):: diff1, diff2
    end function dcdatetime_sub_ff
 
    type(dc_difftime) function dcdatetime_sub_fd(diff, sec) result(result)
      use dc_date_types, only: dc_datetime, dc_difftime
      use dc_types, only: dp
      type(dc_difftime), intent(in):: diff
      real(dp), intent(in):: sec
    end function dcdatetime_sub_fd
 
    type(dc_difftime) function dcdatetime_sub_fr(diff, sec) result(result)
      use dc_date_types, only: dc_datetime, dc_difftime
      type(dc_difftime), intent(in):: diff
      real, intent(in):: sec
    end function dcdatetime_sub_fr
 
    type(dc_difftime) function dcdatetime_sub_fi(diff, sec) result(result)
      use dc_date_types, only: dc_datetime, dc_difftime
      type(dc_difftime), intent(in):: diff
      integer, intent(in):: sec
    end function dcdatetime_sub_fi
  end interface
 
  interface operator(*)
    type(dc_difftime) function dcdatetime_mul_if(factor, diff) result(result) !:doc-priority 51:
      use dc_date_types, only: dc_datetime, dc_difftime
      integer, intent(in):: factor
      type(dc_difftime), intent(in):: diff
    end function dcdatetime_mul_if
 
    type(dc_difftime) function dcdatetime_mul_fi(diff, factor) result(result) !:doc-priority 52:
      use dc_date_types, only: dc_datetime, dc_difftime
      type(dc_difftime), intent(in):: diff
      integer, intent(in):: factor
    end function dcdatetime_mul_fi
 
    type(dc_difftime) function dcdatetime_mul_rf(factor, diff) result(result) !:doc-priority 61:
      use dc_date_types, only: dc_datetime, dc_difftime
      real, intent(in):: factor
      type(dc_difftime), intent(in):: diff
    end function dcdatetime_mul_rf
 
    type(dc_difftime) function dcdatetime_mul_fr(diff, factor) result(result) !:doc-priority 62:
      use dc_date_types, only: dc_datetime, dc_difftime
      type(dc_difftime), intent(in):: diff
      real, intent(in):: factor
    end function dcdatetime_mul_fr
 
    type(dc_difftime) function dcdatetime_mul_df(factor, diff) result(result) !:doc-priority 71:
      use dc_types, only: dp
      use dc_date_types, only: dc_datetime, dc_difftime
      real(dp), intent(in):: factor
      type(dc_difftime), intent(in):: diff
    end function dcdatetime_mul_df
 
    type(dc_difftime) function dcdatetime_mul_fd(diff, factor) result(result) !:doc-priority 72:
      use dc_types, only: dp
      use dc_date_types, only: dc_datetime, dc_difftime
      type(dc_difftime), intent(in):: diff
      real(dp), intent(in):: factor
    end function dcdatetime_mul_fd
 
  end interface
 
  interface operator(/)
    type(dc_difftime) function dcdatetime_div_fi(diff, denominator) result(result)
      use dc_date_types, only: dc_datetime, dc_difftime
      type(dc_difftime), intent(in):: diff
      integer, intent(in):: denominator
    end function dcdatetime_div_fi
 
    type(dc_difftime) function dcdatetime_div_fr(diff, denominator) result(result)
      use dc_date_types, only: dc_datetime, dc_difftime
      type(dc_difftime), intent(in):: diff
      real, intent(in):: denominator
    end function dcdatetime_div_fr
 
    type(dc_difftime) function dcdatetime_div_fd(diff, denominator) result(result)
      use dc_date_types, only: dc_datetime, dc_difftime
      use dc_types, only: dp
      type(dc_difftime), intent(in):: diff
      real(dp), intent(in):: denominator
    end function dcdatetime_div_fd
 
    real(dp) function dcdatetime_div_ff(diff1, diff2) result(result)
      use dc_date_types, only: dc_datetime, dc_difftime
      use dc_types, only: dp
      type(dc_difftime), intent(in):: diff1, diff2
    end function dcdatetime_div_ff
  end interface
 
  interface mod
    type(dc_difftime) function dcdatetime_mod_ff(diff1, diff2) result(result)
      use dc_date_types, only: dc_difftime
      type(dc_difftime), intent(in):: diff1, diff2
    end function dcdatetime_mod_ff
  end interface
 
  interface operator(==)
    logical function dcdatetime_eq_tt(time1, time2) result(result) !:doc-priority 30:
      use dc_date_types, only: dc_datetime, dc_difftime
      type(dc_datetime), intent(in):: time1, time2
    end function dcdatetime_eq_tt
 
    logical function dcdatetime_eq_ff(diff1, diff2) result(result) !:doc-priority 40:
      use dc_date_types, only: dc_datetime, dc_difftime
      type(dc_difftime), intent(in):: diff1, diff2
    end function dcdatetime_eq_ff
 
    logical function dcdatetime_eq_if(i, diff) result(result) !:doc-priority 51:
      use dc_date_types, only: dc_datetime, dc_difftime
      type(dc_difftime), intent(in):: diff
      integer, intent(in):: i
    end function dcdatetime_eq_if
 
    logical function dcdatetime_eq_fi(diff, i) result(result) !:doc-priority 52:
      use dc_date_types, only: dc_datetime, dc_difftime
      type(dc_difftime), intent(in):: diff
      integer, intent(in):: i
    end function dcdatetime_eq_fi
 
    logical function dcdatetime_eq_rf(r, diff) result(result) !:doc-priority 61:
      use dc_date_types, only: dc_datetime, dc_difftime
      type(dc_difftime), intent(in):: diff
      real, intent(in):: r
    end function dcdatetime_eq_rf
 
    logical function dcdatetime_eq_fr(diff, r) result(result) !:doc-priority 62:
      use dc_date_types, only: dc_datetime, dc_difftime
      type(dc_difftime), intent(in):: diff
      real, intent(in):: r
    end function dcdatetime_eq_fr
 
    logical function dcdatetime_eq_df(d, diff) result(result) !:doc-priority 71:
      use dc_types, only: dp
      use dc_date_types, only: dc_datetime, dc_difftime
      type(dc_difftime), intent(in):: diff
      real(dp), intent(in):: d
    end function dcdatetime_eq_df
 
    logical function dcdatetime_eq_fd(diff, d) result(result) !:doc-priority 72:
      use dc_types, only: dp
      use dc_date_types, only: dc_datetime, dc_difftime
      type(dc_difftime), intent(in):: diff
      real(dp), intent(in):: d
    end function dcdatetime_eq_fd
 
  end interface
 
 
  interface operator(>)
    logical function dcdatetime_gt_tt(time1, time2) result(result) !:doc-priority 30:
      use dc_date_types, only: dc_datetime, dc_difftime
      type(dc_datetime), intent(in):: time1, time2
    end function dcdatetime_gt_tt
 
    logical function dcdatetime_gt_ff(diff1, diff2) result(result) !:doc-priority 40:
      use dc_date_types, only: dc_datetime, dc_difftime
      type(dc_difftime), intent(in):: diff1, diff2
    end function dcdatetime_gt_ff
 
    logical function dcdatetime_gt_fi(diff, factor) result(result) !:doc-priority 42:
      use dc_date_types, only: dc_datetime, dc_difftime
      type(dc_difftime), intent(in):: diff
      integer, intent(in):: factor
    end function dcdatetime_gt_fi
 
    logical function dcdatetime_gt_if(factor, diff) result(result) !:doc-priority 44:
      use dc_date_types, only: dc_datetime, dc_difftime
      integer, intent(in):: factor
      type(dc_difftime), intent(in):: diff
    end function dcdatetime_gt_if
  end interface
 
  interface operator(<)
    logical function dcdatetime_lt_tt(time1, time2) result(result) !:doc-priority 30:
      use dc_date_types, only: dc_datetime, dc_difftime
      type(dc_datetime), intent(in):: time1, time2
    end function dcdatetime_lt_tt
 
    logical function dcdatetime_lt_ff(diff1, diff2) result(result) !:doc-priority 40:
      use dc_date_types, only: dc_datetime, dc_difftime
      type(dc_difftime), intent(in):: diff1, diff2
    end function dcdatetime_lt_ff
 
    logical function dcdatetime_lt_fi(diff, factor) result(result) !:doc-priority 42:
      use dc_date_types, only: dc_datetime, dc_difftime
      type(dc_difftime), intent(in):: diff
      integer, intent(in):: factor
    end function dcdatetime_lt_fi
 
    logical function dcdatetime_lt_if(factor, diff) result(result) !:doc-priority 44:
      use dc_date_types, only: dc_datetime, dc_difftime
      integer, intent(in):: factor
      type(dc_difftime), intent(in):: diff
    end function dcdatetime_lt_if
  end interface
 
  interface operator(>=)
    logical function dcdatetime_ge_tt(time1, time2) result(result) !:doc-priority 30:
      use dc_date_types, only: dc_datetime, dc_difftime
      type(dc_datetime), intent(in):: time1, time2
    end function dcdatetime_ge_tt
 
    logical function dcdatetime_ge_ff(diff1, diff2) result(result) !:doc-priority 40:
      use dc_date_types, only: dc_datetime, dc_difftime
      type(dc_difftime), intent(in):: diff1, diff2
    end function dcdatetime_ge_ff
 
    logical function dcdatetime_ge_fi(diff, factor) result(result) !:doc-priority 42:
      use dc_date_types, only: dc_datetime, dc_difftime
      type(dc_difftime), intent(in):: diff
      integer, intent(in):: factor
    end function dcdatetime_ge_fi
 
    logical function dcdatetime_ge_if(factor, diff) result(result) !:doc-priority 44:
      use dc_date_types, only: dc_datetime, dc_difftime
      integer, intent(in):: factor
      type(dc_difftime), intent(in):: diff
    end function dcdatetime_ge_if
  end interface
 
  interface operator(<=)
    logical function dcdatetime_le_tt(time1, time2) result(result) !:doc-priority 30:
      use dc_date_types, only: dc_datetime, dc_difftime
      type(dc_datetime), intent(in):: time1, time2
    end function dcdatetime_le_tt
 
    logical function dcdatetime_le_ff(diff1, diff2) result(result) !:doc-priority 40:
      use dc_date_types, only: dc_datetime, dc_difftime
      type(dc_difftime), intent(in):: diff1, diff2
    end function dcdatetime_le_ff
 
    logical function dcdatetime_le_fi(diff, factor) result(result) !:doc-priority 42:
      use dc_date_types, only: dc_datetime, dc_difftime
      type(dc_difftime), intent(in):: diff
      integer, intent(in):: factor
    end function dcdatetime_le_fi
 
    logical function dcdatetime_le_if(factor, diff) result(result) !:doc-priority 44:
      use dc_date_types, only: dc_datetime, dc_difftime
      integer, intent(in):: factor
      type(dc_difftime), intent(in):: diff
    end function dcdatetime_le_if
  end interface
 
  interface max
    type(dc_datetime) function dcdatetime_max_tt(time1, time2) result(result) !:doc-priority 30:
      use dc_date_types, only: dc_datetime, dc_difftime
      type(dc_datetime), intent(in):: time1, time2
    end function dcdatetime_max_tt
 
    type(dc_difftime) function dcdatetime_max_ff(diff1, diff2) result(result) !:doc-priority 40:
      use dc_date_types, only: dc_datetime, dc_difftime
      type(dc_difftime), intent(in):: diff1, diff2
    end function dcdatetime_max_ff
  end interface
 
  interface min
    type(dc_datetime) function dcdatetime_min_tt(time1, time2) result(result) !:doc-priority 30:
      use dc_date_types, only: dc_datetime, dc_difftime
      type(dc_datetime), intent(in):: time1, time2
    end function dcdatetime_min_tt
 
    type(dc_difftime) function dcdatetime_min_ff(diff1, diff2) result(result) !:doc-priority 40:
      use dc_date_types, only: dc_datetime, dc_difftime
      type(dc_difftime), intent(in):: diff1, diff2
    end function dcdatetime_min_ff
  end interface
 
  !-----------------------------------------------
  ! 後方互換用
  ! For backward compatibility
  interface create
    subroutine dcdatetimecreate1_bc(time, &
      & year, mon, day, hour, min, sec, &
      & zone, caltype, day_seconds, err) !:doc-priority 40:
      use dc_types, only: dp
      use dc_date_types, only: dc_datetime
      use dc_scaledsec, only: dc_scaled_sec
      type(dc_datetime), intent(out):: time
      integer, intent(in), optional:: year, mon, day, hour, min
      real(DP),intent(in), optional:: sec, day_seconds
      character(*), intent(in), optional :: zone
      integer, intent(in), optional:: caltype
      logical, intent(out), optional:: err
    end subroutine dcdatetimecreate1_bc
 
    subroutine dcdifftimecreate1_bc(diff, &
      & year, mon, day, hour, min, sec, day_seconds ) !:doc-priority 60:
      use dc_types, only: dp
      use dc_date_types, only: dc_difftime
      use dc_scaledsec, only: dc_scaled_sec
      type(dc_difftime), intent(out) :: diff
      integer, intent(in), optional:: year, mon, day, hour, min
      real(DP),intent(in), optional:: sec, day_seconds
    end subroutine dcdifftimecreate1_bc
 
    subroutine dcdifftimecreate2_bc(diff, value, unit, unit_symbol, err) !:doc-priority 70:
      use dc_types, only: dp
      use dc_date_types, only: dc_difftime
      type(dc_difftime), intent(out) :: diff
      real(DP), intent(in) :: value
      character(*), intent(in) :: unit
      integer, intent(in), optional :: unit_symbol
      logical, intent(out), optional :: err
    end subroutine dcdifftimecreate2_bc
  end interface
 
  interface putline
    subroutine dcdatetimeputline_bc(time, unit)
      use dc_date_types, only: dc_datetime
      type(dc_datetime), intent(in) :: time
      integer, intent(in), optional :: unit
    end subroutine dcdatetimeputline_bc
 
    subroutine dcdifftimeputline_bc(diff, unit)
      use dc_date_types, only: dc_difftime
      type(dc_difftime), intent(in) :: diff
      integer, intent(in), optional :: unit
    end subroutine dcdifftimeputline_bc
  end interface
 
end module dc_date_generic