dcdatetimeeval.f90

Go to the documentation of this file.

!-----------------------------------------------------------------------
! Copyright (c) 2000-2026 Gtool Development Group. All rights reserved.
!-----------------------------------------------------------------------
!>
!> @file dcdatetimeeval.f90
!> @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 Conversion from DC_DATETIME/DC_DIFFTIME to date/time components
!> @details
!> Procedures provided in this file are available through dc_date module.
!> @enden
!>
!> @ja
!> @brief DC_DATETIME/DC_DIFFTIME 型変数から月日秒への変換
!> @details
!> このファイルで提供される手続き群は dc_date モジュールにて提供されます.
!> @endja
!>
 
!> @en
!> @brief Convert DC_DATETIME to date/time components
!> @details
!> Converts DC_DATETIME variable `time` to year, month, day, hour,
!> minute, second, calendar type, and timezone.
!>
!> @param[in] time DC_DATETIME variable to convert
!> @param[out] year Year (optional)
!> @param[out] mon Month (optional)
!> @param[out] day Day (optional)
!> @param[out] hour Hour (optional)
!> @param[out] min Minute (optional)
!> @param[out] sec Second (optional)
!> @param[out] caltype Calendar type (optional)
!> @param[out] zone Timezone (offset from UTC) (optional)
!> @param[out] sclyear Year as DC_SCALED_SEC (optional)
!> @param[out] sclmon Month as DC_SCALED_SEC (optional)
!> @param[out] sclday Day as DC_SCALED_SEC (optional)
!> @param[out] sclsec Second as DC_SCALED_SEC (optional)
!> @enden
!>
!> @ja
!> @brief DC_DATETIME を日時成分に変換
!> @details
!> DC_DATETIME 型変数 `time` を年, 月, 日, 時間, 分, 秒,
!> 暦法, タイムゾーンに変換して返します.
!>
!> @param[in] time 変換する DC_DATETIME 型変数
!> @param[out] year 年 (省略可能)
!> @param[out] mon 月 (省略可能)
!> @param[out] day 日 (省略可能)
!> @param[out] hour 時 (省略可能)
!> @param[out] min 分 (省略可能)
!> @param[out] sec 秒 (省略可能)
!> @param[out] caltype 暦法 (省略可能)
!> @param[out] zone タイムゾーン (UTC からの時差) (省略可能)
!> @param[out] sclyear 年 (DC_SCALED_SEC 型) (省略可能)
!> @param[out] sclmon 月 (DC_SCALED_SEC 型) (省略可能)
!> @param[out] sclday 日 (DC_SCALED_SEC 型) (省略可能)
!> @param[out] sclsec 秒 (DC_SCALED_SEC 型) (省略可能)
!> @endja
subroutine dcdatetimeeval1(time, year, mon, day, hour, min, &
  & sec, caltype, zone, sclyear, sclmon, sclday, sclsec)
  use dc_types, only: dp
  use dc_date_types, only: dc_datetime, &
    & cyclic_mdays, cal_noleap, cal_julian, cal_cyclic, &
    & year_months, year_days, four_years, four_century, &
    & hour_seconds, min_seconds
  use dc_scaledsec, only:  dc_scaled_sec, &
    & assignment(=), dcscaledsecputline, &
    & operator(==), operator(>), operator(<), operator(>=), operator(<=), &
    & operator(+), operator(-), operator(*), operator(/), mod, modulo, &
    & abs, int, floor, ceiling
  use dc_trace, only: beginsub, endsub
  implicit none
  type(dc_datetime), intent(in):: time
  integer, intent(out), optional:: year ! 年
  integer, intent(out), optional:: mon  ! 月
  integer, intent(out), optional:: day  ! 日
  integer, intent(out), optional:: hour ! 時
  integer, intent(out), optional:: min  ! 分
  real(DP),intent(out), optional:: sec  ! 秒
  integer, intent(out), optional:: caltype ! 暦法
  character(*), intent(out), optional:: zone ! タイムゾーン (UTC からの時差)
  type(dc_scaled_sec), intent(out), optional:: sclyear ! 年 (DC_SCALED_SEC 型)
  type(dc_scaled_sec), intent(out), optional:: sclmon  ! 月 (DC_SCALED_SEC 型)
  type(dc_scaled_sec), intent(out), optional:: sclday  ! 日 (DC_SCALED_SEC 型)
  type(dc_scaled_sec), intent(out), optional:: sclsec  ! 秒 (DC_SCALED_SEC 型)
 
  type(dc_scaled_sec):: iyear, month, iday, imon, isec
  !character(*), parameter :: subname = 'DCDateTimeEval1'
continue
  !call BeginSub(subname)
  if (present(zone)) then
    zone = time % zone
  end if
  if (present(caltype)) then
    caltype = time % caltype
  end if
  isec = time % sec
  if (present(hour)) then
    hour = floor(isec / hour_seconds)
    isec = modulo(isec, hour_seconds)
  end if
  if (present(min)) then
    min = floor(isec / min_seconds)
    isec = modulo(isec, min_seconds)
  end if
  if (present(sec)) then
    sec = isec
  end if
  if (present(sclsec)) then
    sclsec = isec
  end if
 
  if (time % caltype == cal_cyclic) then
    iday = time % day
    if (present(year)) year = 0
    if (present(sclyear)) sclyear = 0
    if (present(sclmon)) then
      sclmon = floor(iday / cyclic_mdays)
      iday = ceiling( modulo(iday, cyclic_mdays) )
    elseif (present(mon)) then
      mon = floor(iday / cyclic_mdays)
      iday = ceiling( modulo(iday, cyclic_mdays) )
    end if
    if (present(day)) day = iday
    if (present(sclday)) sclday = iday
    goto 999
  endif
  if (time % caltype == cal_noleap) then
    iday = int( modulo(time%day - 91, year_days) )
    iyear = int( (time%day - 91 - iday) / year_days )
  else
    if (time % caltype == cal_julian) then
      iday = int( modulo(time%day - 92, four_years) )
      iyear = int( (time%day - 92 - iday) / four_years ) * 4
    elseif (time%day < 640196) then
      iday = int( modulo(time%day - 92, four_years) )
      iyear = int( (time%day - 92 - iday) / four_years ) * 4
    else
      iday = int( modulo(time%day - 94, four_century) )
      iyear = int( (time%day - 94 - iday) / four_century ) * 400
      if (iday == four_century - 1) then
        iyear = iyear + 300
        iday = 36525
      else
        iyear = iyear + int( iday / 36524 ) * 100
        iday = int( modulo(iday, 36524) )
      endif
      iyear = iyear + int( iday / four_years ) * 4
      iday = int( modulo(iday, four_years) )
    endif
    if (iday == four_years - 1) then
      iyear = iyear + 3
      iday = year_days
    else
      iyear = iyear + int( iday / year_days )
      iday = int( modulo(iday, year_days) )
    endif
  endif
 
  iday = iday * 10 + 922
  month = int( iday / 306 )
 
  if (present(sclyear)) then
    imon = mod(month - 1, year_months) + 1
    sclyear = iyear + int( (month - imon) / year_months )
  elseif (present(year)) then
    imon = mod(month - 1, year_months) + 1
    year = iyear + int( (month - imon) / year_months )
  else
    imon = month
  end if
  if (present(sclmon)) then
    iday = int( mod(iday, 306) / 10 ) + 1
    sclmon = imon
  elseif (present(mon)) then
    iday = int( mod(iday, 306) / 10 ) + 1
    mon = imon
  else
    iday = int( iday / 10 )  + 1
  end if
 
  if (present(day)) day = iday
  if (present(sclday)) sclday = iday
 
999 continue
  !call EndSub(subname)
end subroutine dcdatetimeeval1
 
 
!> @en
!> @brief Convert DC_DIFFTIME to time components
!> @details
!> Converts DC_DIFFTIME variable `diff` to year, month, day, hour,
!> minute, second, and nondimensional time.
!>
!> @param[in] diff DC_DIFFTIME variable to convert
!> @param[out] year Year (optional)
!> @param[out] mon Month (optional)
!> @param[out] day Day (optional)
!> @param[out] hour Hour (optional)
!> @param[out] min Minute (optional)
!> @param[out] sec Second (optional)
!> @param[out] nondim Nondimensional time (optional)
!> @param[out] sclyear Year as DC_SCALED_SEC (optional)
!> @param[out] sclmon Month as DC_SCALED_SEC (optional)
!> @param[out] sclday Day as DC_SCALED_SEC (optional)
!> @param[out] sclsec Second as DC_SCALED_SEC (optional)
!> @param[out] sclnondim Nondimensional time as DC_SCALED_SEC (optional)
!> @param[out] err Error flag (optional)
!> @enden
!>
!> @ja
!> @brief DC_DIFFTIME を時間成分に変換
!> @details
!> DC_DIFFTIME 型変数 `diff` を年, 月, 日, 時間, 分, 秒,
!> 無次元時間に変換して返します.
!>
!> @param[in] diff 変換する DC_DIFFTIME 型変数
!> @param[out] year 年 (省略可能)
!> @param[out] mon 月 (省略可能)
!> @param[out] day 日 (省略可能)
!> @param[out] hour 時 (省略可能)
!> @param[out] min 分 (省略可能)
!> @param[out] sec 秒 (省略可能)
!> @param[out] nondim 無次元時間 (省略可能)
!> @param[out] sclyear 年 (DC_SCALED_SEC 型) (省略可能)
!> @param[out] sclmon 月 (DC_SCALED_SEC 型) (省略可能)
!> @param[out] sclday 日 (DC_SCALED_SEC 型) (省略可能)
!> @param[out] sclsec 秒 (DC_SCALED_SEC 型) (省略可能)
!> @param[out] sclnondim 無次元時間 (DC_SCALED_SEC 型) (省略可能)
!> @param[out] err エラーフラグ (省略可能)
!> @endja
subroutine dcdifftimeeval1(diff, &
  & year, mon, day, hour, min, sec, nondim, &
  & sclyear, sclmon, sclday, sclsec, sclnondim, err)
  use dc_types, only: dp
  use dc_trace, only: beginsub, endsub
  use dc_error, only: storeerror, dc_noerr, dc_enodimtime, dc_edimtime
  use dc_date_types, only: dc_difftime, &
    & min_seconds, hour_seconds, year_months
  use dc_scaledsec, only:  dc_scaled_sec, &
    & assignment(=), dcscaledsecputline, &
    & operator(==), operator(>), operator(<), operator(>=), operator(<=), &
    & operator(+), operator(-), operator(*), operator(/), mod, modulo, &
    & abs, int, floor, ceiling
  implicit none
  type(dc_difftime), intent(in):: diff
  integer, intent(out), optional:: year ! 年
  integer, intent(out), optional:: mon  ! 月
  integer, intent(out), optional:: day  ! 日
  integer, intent(out), optional:: hour ! 時
  integer, intent(out), optional:: min  ! 分
  real(DP),intent(out), optional:: sec  ! 秒
  real(DP),intent(out), optional:: nondim  ! 無次元時間. Nondimensional time
  type(dc_scaled_sec), intent(out), optional:: sclyear ! 年 (DC_SCALED_SEC 型)
  type(dc_scaled_sec), intent(out), optional:: sclmon  ! 月 (DC_SCALED_SEC 型)
  type(dc_scaled_sec), intent(out), optional:: sclday  ! 日 (DC_SCALED_SEC 型)
  type(dc_scaled_sec), intent(out), optional:: sclsec  ! 秒 (DC_SCALED_SEC 型)
  type(dc_scaled_sec), intent(out), optional:: sclnondim  ! 無次元時間 (DC_SCALED_SEC 型)
  logical, intent(out), optional :: err
  type(dc_scaled_sec):: imon, isec
  integer:: stat
  character(*), parameter :: subname = 'DCDiffTimeEval1'
continue
  !call BeginSub(subname)
  stat = dc_noerr
  if ( present(sclnondim) ) then
    if ( .not. diff % nondim_flag ) then
      stat = dc_edimtime
      goto 999
    end if
    sclnondim = diff % sec
  elseif ( present(nondim) ) then
    if ( .not. diff % nondim_flag ) then
      stat = dc_edimtime
      goto 999
    end if
    nondim = diff % sec
  else
    if ( diff % nondim_flag ) then
      stat = dc_enodimtime
      goto 999
    end if
  end if
 
  imon = diff % mon
  isec = diff % sec
  if (present(sclyear)) then
    sclyear = int( imon / year_months )
    imon = mod(imon, year_months)
  elseif (present(year)) then
    year = int( imon / year_months )
    imon = mod(imon, year_months)
  endif
 
  if (present(sclmon)) then
    sclmon = imon
  elseif (present(mon)) then
    mon = imon
  endif
 
  if (present(sclday)) then
    sclday = diff % day
  elseif (present(day)) then
    day = diff % day
  else
    isec = isec + diff % day * diff % day_seconds
  endif
 
  if (present(hour)) then
    hour = int(isec / hour_seconds)
    isec = mod(isec, hour_seconds)
  endif
  if (present(min)) then
    min = int(isec / min_seconds)
    isec = mod(isec, min_seconds)
  endif
 
  if (present(sec)) then
    sec = isec
  endif
  if (present(sclsec)) then
    sclsec = isec
  endif
999 continue
  call storeerror(stat, subname, err)
  !call EndSub(subname)
end subroutine dcdifftimeeval1
 
 
!> @en
!> @brief Convert DC_DATETIME to days
!> @details
!> Converts DC_DATETIME variable to number of days as double precision real.
!> (e.g., 12 hours is converted to 0.5 days)
!>
!> @param[in] time DC_DATETIME variable to convert
!> @return Number of days as double precision real
!> @enden
!>
!> @ja
!> @brief DC_DATETIME を日数に変換
!> @details
!> DC_DATETIME 型変数の日時を日数に換算して倍精度実数型変数で返します.
!> (例えば 12 時間は 0.5 日と換算されます)
!>
!> @param[in] time 変換する DC_DATETIME 型変数
!> @return 日数 (倍精度実数型)
!> @endja
function dcdatetimeevalday(time) result(result)
  use dc_types, only: dp
  use dc_date_generic, only: eval
  use dc_date_types, only: dc_datetime
  use dc_scaledsec, only: dc_scaled_sec, assignment(=), operator(/), operator(+)
  implicit none
  real(dp):: result
  type(dc_datetime), intent(in):: time
  type(dc_scaled_sec):: day, sec
continue
  call eval(time, sclday = day, sclsec = sec)
  result = day + sec / time % day_seconds
end function dcdatetimeevalday
 
!> @en
!> @brief Convert DC_DIFFTIME to days
!> @details
!> Converts DC_DIFFTIME variable to number of days as double precision real.
!> (e.g., 12 hours is converted to 0.5 days)
!>
!> One month is converted using dc_date_types#CYCLIC_MDAYS.
!>
!> @param[in] diff DC_DIFFTIME variable to convert
!> @return Number of days as double precision real
!> @enden
!>
!> @ja
!> @brief DC_DIFFTIME を日数に変換
!> @details
!> DC_DIFFTIME 型変数の日時を日数に換算して倍精度実数型変数で返します.
!> (例えば 12 時間は 0.5 日と換算されます)
!>
!> 1 ヶ月は dc_date_types#CYCLIC_MDAYS と換算します.
!>
!> @param[in] diff 変換する DC_DIFFTIME 型変数
!> @return 日数 (倍精度実数型)
!> @endja
function dcdifftimeevalday(diff) result(result)
  use dc_types, only: dp
  use dc_date_generic, only: eval
  use dc_date_types, only: dc_difftime, cyclic_mdays
  use dc_scaledsec, only: dc_scaled_sec, assignment(=), operator(/), &
    & operator(+), operator(*), int
  implicit none
  real(dp):: result
  type(dc_difftime), intent(in):: diff
  type(dc_scaled_sec):: day, mon, sec
continue
  call eval(diff, sclmon = mon, sclday = day, sclsec = sec)
  result = int(mon * cyclic_mdays) + day + sec / diff % day_seconds
end function dcdifftimeevalday
 
 
!> @en
!> @brief Convert DC_DATETIME to hours
!> @details
!> Converts DC_DATETIME variable to hours as double precision real.
!> (e.g., 2 days is 48 hours, 30 minutes is 0.5 hours)
!>
!> @param[in] time DC_DATETIME variable to convert
!> @return Number of hours as double precision real
!> @enden
!>
!> @ja
!> @brief DC_DATETIME を時間に変換
!> @details
!> DC_DATETIME 型変数の日時を時間に換算して倍精度実数型変数で返します.
!> (例えば 2 日は 48 時間に, 30 分は 0.5 時間と換算されます)
!>
!> @param[in] time 変換する DC_DATETIME 型変数
!> @return 時間 (倍精度実数型)
!> @endja
function dcdatetimeevalhour(time) result(result)
  use dc_types, only: dp
  use dc_date_generic, only: eval
  use dc_date_types, only: dc_datetime, hour_seconds
  use dc_scaledsec, only: dc_scaled_sec, assignment(=), operator(/), &
    & operator(+), operator(*), int
  implicit none
  real(dp):: result
  type(dc_datetime), intent(in):: time
  type(dc_scaled_sec):: day, sec
continue
  call eval(time, sclday = day, sclsec = sec)
  result = (day * time % day_seconds + sec) / hour_seconds
end function dcdatetimeevalhour
 
!> @en
!> @brief Convert DC_DIFFTIME to hours
!> @details
!> Converts DC_DIFFTIME variable to hours as double precision real.
!> (e.g., 2 days is 48 hours, 30 minutes is 0.5 hours)
!>
!> One month is converted using dc_date_types#CYCLIC_MDAYS.
!>
!> @param[in] diff DC_DIFFTIME variable to convert
!> @return Number of hours as double precision real
!> @enden
!>
!> @ja
!> @brief DC_DIFFTIME を時間に変換
!> @details
!> DC_DIFFTIME 型変数の日時を時間に換算して倍精度実数型変数で返します.
!> (例えば 2 日は 48 時間に, 30 分は 0.5 時間と換算されます)
!>
!> 1 ヶ月は dc_date_types#CYCLIC_MDAYS と換算します.
!>
!> @param[in] diff 変換する DC_DIFFTIME 型変数
!> @return 時間 (倍精度実数型)
!> @endja
function dcdifftimeevalhour(diff) result(result)
  use dc_types, only: dp
  use dc_date_generic, only: eval
  use dc_date_types, only: dc_difftime, hour_seconds, cyclic_mdays
  use dc_scaledsec, only: dc_scaled_sec, assignment(=), operator(/), &
    & operator(+), operator(*), int
  implicit none
  real(dp):: result
  type(dc_difftime), intent(in):: diff
  type(dc_scaled_sec):: mon, day, sec
continue
  call eval(diff, sclmon = mon, sclday = day, sclsec = sec)
  result = ( int(mon * cyclic_mdays) + day &
    &         * diff % day_seconds + sec) / hour_seconds
end function dcdifftimeevalhour
 
 
!> @en
!> @brief Convert DC_DATETIME to minutes
!> @details
!> Converts DC_DATETIME variable to minutes as double precision real.
!> (e.g., 1 day is 1440 minutes, 30 seconds is 0.5 minutes)
!>
!> @param[in] time DC_DATETIME variable to convert
!> @return Number of minutes as double precision real
!> @enden
!>
!> @ja
!> @brief DC_DATETIME を分に変換
!> @details
!> DC_DATETIME 型変数の日時を分に換算して倍精度実数型変数で返します.
!> (例えば 1 日は 1440 分に, 30 秒は 0.5 分と換算されます)
!>
!> @param[in] time 変換する DC_DATETIME 型変数
!> @return 分 (倍精度実数型)
!> @endja
function dcdatetimeevalmin(time) result(result)
  use dc_types, only: dp
  use dc_date_generic, only: eval
  use dc_date_types, only: dc_datetime, min_seconds
  use dc_scaledsec, only: dc_scaled_sec, assignment(=), operator(/), &
    & operator(+), operator(*), int
  implicit none
  real(dp):: result
  type(dc_datetime), intent(in):: time
  type(dc_scaled_sec):: day, sec
continue
  call eval(time, sclday = day, sclsec = sec)
  result = (day * time % day_seconds + sec) / min_seconds
end function dcdatetimeevalmin
 
!> @en
!> @brief Convert DC_DIFFTIME to minutes
!> @details
!> Converts DC_DIFFTIME variable to minutes as double precision real.
!> (e.g., 1 day is 1440 minutes, 30 seconds is 0.5 minutes)
!>
!> One month is converted using dc_date_types#CYCLIC_MDAYS.
!>
!> @param[in] diff DC_DIFFTIME variable to convert
!> @return Number of minutes as double precision real
!> @enden
!>
!> @ja
!> @brief DC_DIFFTIME を分に変換
!> @details
!> DC_DIFFTIME 型変数の日時を分に換算して倍精度実数型変数で返します.
!> (例えば 1 日は 1440 分に, 30 秒は 0.5 分と換算されます)
!>
!> 1 ヶ月は dc_date_types#CYCLIC_MDAYS と換算します.
!>
!> @param[in] diff 変換する DC_DIFFTIME 型変数
!> @return 分 (倍精度実数型)
!> @endja
function dcdifftimeevalmin(diff) result(result)
  use dc_types, only: dp
  use dc_date_generic, only: eval
  use dc_date_types, only: dc_difftime, min_seconds, cyclic_mdays
  use dc_scaledsec, only: dc_scaled_sec, assignment(=), operator(/), &
    & operator(+), operator(*), int
  implicit none
  real(dp):: result
  type(dc_difftime), intent(in):: diff
  type(dc_scaled_sec):: mon, day, sec
continue
  call eval(diff, sclmon = mon, sclday = day, sclsec = sec)
  result = ( int(mon * cyclic_mdays) + day &
    &         * diff % day_seconds + sec) / min_seconds
end function dcdifftimeevalmin
 
 
!> @en
!> @brief Convert DC_DATETIME to seconds
!> @details
!> Converts DC_DATETIME variable to seconds as double precision real.
!>
!> @warning The year component is ignored. i.e., time containing 1999-01-01
!>          and time containing 2007-01-01 return the same value.
!>          (This may not be the desired behavior)
!>
!> @param[in] time DC_DATETIME variable to convert
!> @return Number of seconds as double precision real
!> @enden
!>
!> @ja
!> @brief DC_DATETIME を秒に変換
!> @details
!> DC_DATETIME 型変数の日時を秒に換算して倍精度実数型変数で返します.
!>
!> @warning 年の要素は無視されます. すなわち, 1999-01-01 が格納された time と
!>          2007-01-01 が格納された time からは同じ値が返ります.
!>          (これはもしかすると望ましくない動作かもしれません)
!>
!> @param[in] time 変換する DC_DATETIME 型変数
!> @return 秒 (倍精度実数型)
!> @endja
function dcdatetimeevalsec(time) result(result)
  use dc_types, only: dp
  use dc_date_generic, only: eval
  use dc_date_types, only: dc_datetime
  use dc_scaledsec, only: assignment(=)
  implicit none
  real(dp):: result
  type(dc_datetime), intent(in):: time
  integer:: day
  real(dp):: sec, day_seconds
continue
  call eval(time, day = day, sec = sec)
  day_seconds = time % day_seconds
  result = day * day_seconds + sec
end function dcdatetimeevalsec
 
!> @en
!> @brief Convert DC_DIFFTIME to seconds
!> @details
!> Converts DC_DIFFTIME variable to seconds as double precision real.
!>
!> One month is converted using dc_date_types#CYCLIC_MDAYS.
!>
!> @param[in] diff DC_DIFFTIME variable to convert
!> @return Number of seconds as double precision real
!> @enden
!>
!> @ja
!> @brief DC_DIFFTIME を秒に変換
!> @details
!> DC_DIFFTIME 型変数の日時を秒に換算して倍精度実数型変数で返します.
!>
!> 1 ヶ月は dc_date_types#CYCLIC_MDAYS と換算します.
!>
!> @param[in] diff 変換する DC_DIFFTIME 型変数
!> @return 秒 (倍精度実数型)
!> @endja
function dcdifftimeevalsec(diff) result(result)
  use dc_types, only: dp
  use dc_date_generic, only: eval
  use dc_date_types, only: dc_difftime, cyclic_mdays
  use dc_scaledsec, only: assignment(=)
  implicit none
  real(dp):: result
  type(dc_difftime), intent(in):: diff
  integer:: mon, day
  real(dp):: sec, day_seconds
continue
  if ( .not. diff % nondim_flag ) then
    call eval(diff, mon = mon, day = day, sec = sec)
    day_seconds = diff % day_seconds
    result = int(mon * cyclic_mdays) + day * day_seconds + sec
  else
    call eval(diff, nondim = result)
  end if
end function dcdifftimeevalsec
 
!> @en
!> @brief Convert DC_DIFFTIME to nondimensional time
!> @details
!> Converts DC_DIFFTIME variable to nondimensional time as double precision real.
!>
!> One month is converted using dc_date_types#CYCLIC_MDAYS.
!>
!> @param[in] diff DC_DIFFTIME variable to convert
!> @return Nondimensional time as double precision real
!> @enden
!>
!> @ja
!> @brief DC_DIFFTIME を無次元時間に変換
!> @details
!> DC_DIFFTIME 型変数の日時を無次元時間に換算して倍精度実数型変数で返します.
!>
!> 1 ヶ月は dc_date_types#CYCLIC_MDAYS と換算します.
!>
!> @param[in] diff 変換する DC_DIFFTIME 型変数
!> @return 無次元時間 (倍精度実数型)
!> @endja
function dcdifftimeevalnondim(diff) result(result)
  use dc_types, only: dp
  use dc_date_generic, only: eval
  use dc_date_types, only: dc_difftime
  implicit none
  real(dp):: result
  type(dc_difftime), intent(in):: diff
  real(dp):: nondim
continue
  call eval(diff, nondim=nondim)
  result = nondim
end function dcdifftimeevalnondim
 
!> @en
!> @brief Convert DC_DATETIME to seconds as DC_SCALED_SEC
!> @details
!> Converts DC_DATETIME variable to seconds as DC_SCALED_SEC type.
!>
!> @warning The year component is ignored. i.e., time containing 1999-01-01
!>          and time containing 2007-01-01 return the same value.
!>          (This may not be the desired behavior)
!>
!> @param[in] time DC_DATETIME variable to convert
!> @return Seconds as DC_SCALED_SEC type
!> @enden
!>
!> @ja
!> @brief DC_DATETIME を秒に変換 (DC_SCALED_SEC 型)
!> @details
!> DC_DATETIME 型変数の日時を秒に換算して DC_SCALED_SEC 型で返します.
!>
!> @warning 年の要素は無視されます. すなわち, 1999-01-01 が格納された time と
!>          2007-01-01 が格納された time からは同じ値が返ります.
!>          (これはもしかすると望ましくない動作かもしれません)
!>
!> @param[in] time 変換する DC_DATETIME 型変数
!> @return 秒 (DC_SCALED_SEC 型)
!> @endja
function dcdatetimeevalsclsec(time) result(result)
  use dc_date_generic, only: eval
  use dc_date_types, only: dc_datetime
  use dc_scaledsec, only: dc_scaled_sec, operator(/), &
    & operator(+), operator(*), int
  implicit none
  type(dc_scaled_sec):: result
  type(dc_datetime), intent(in):: time
  type(dc_scaled_sec):: day, sec
continue
  call eval(time, sclday = day, sclsec = sec)
  result = day * time % day_seconds + sec
end function dcdatetimeevalsclsec
 
!> @en
!> @brief Convert DC_DIFFTIME to seconds as DC_SCALED_SEC
!> @details
!> Converts DC_DIFFTIME variable to seconds as DC_SCALED_SEC type.
!>
!> One month is converted using dc_date_types#CYCLIC_MDAYS.
!>
!> @param[in] diff DC_DIFFTIME variable to convert
!> @return Seconds as DC_SCALED_SEC type
!> @enden
!>
!> @ja
!> @brief DC_DIFFTIME を秒に変換 (DC_SCALED_SEC 型)
!> @details
!> DC_DIFFTIME 型変数の日時を秒に換算して DC_SCALED_SEC 型で返します.
!>
!> 1 ヶ月は dc_date_types#CYCLIC_MDAYS と換算します.
!>
!> @param[in] diff 変換する DC_DIFFTIME 型変数
!> @return 秒 (DC_SCALED_SEC 型)
!> @endja
function dcdifftimeevalsclsec(diff) result(result)
  use dc_date_generic, only: eval
  use dc_date_types, only: dc_difftime, cyclic_mdays
  use dc_scaledsec, only: dc_scaled_sec, operator(/), &
    & operator(==), operator(+), operator(*), int
  implicit none
  type(dc_scaled_sec):: result
  type(dc_difftime), intent(in):: diff
  type(dc_scaled_sec):: mon, day, sec
  type(dc_scaled_sec):: zero_sec
continue
  if ( .not. diff % nondim_flag ) then
    call eval(diff, sclmon = mon, sclday = day, sclsec = sec)
    if ( mon == zero_sec ) then
      result = day * diff % day_seconds + sec
    else
      result = ( int(mon * cyclic_mdays) + day ) * diff % day_seconds + sec
    end if
  else
    call eval(diff, sclnondim = sec)
    result = sec
  end if
end function dcdifftimeevalsclsec
 
!> @en
!> @brief Convert DC_DATETIME by specified unit
!> @details
!> Converts DC_DATETIME variable to the specified unit and returns
!> as double precision real.
!>
!> For `unit`, the following values can be specified:
!> - dc_date_types#UNIT_DAY (day)
!> - dc_date_types#UNIT_HOUR (hour)
!> - dc_date_types#UNIT_MIN (minute)
!> - dc_date_types#UNIT_SEC (second)
!>
!> For `unit_symbol`, the following values can be specified:
!> - dc_date_types#UNIT_SYMBOL_DAY (day)
!> - dc_date_types#UNIT_SYMBOL_HOUR (hour)
!> - dc_date_types#UNIT_SYMBOL_MIN (minute)
!> - dc_date_types#UNIT_SYMBOL_SEC (second)
!>
!> Returns 0.0 if invalid unit is specified or neither argument is given.
!>
!> @param[in] time DC_DATETIME variable to convert
!> @param[in] unit Unit string
!> @param[in] unit_symbol Unit symbol constant (optional)
!> @return Converted value as double precision real
!> @enden
!>
!> @ja
!> @brief DC_DATETIME を指定単位で変換
!> @details
!> DC_DATETIME 型変数の日時を `unit` または `unit_symbol` の単位に
!> 換算して倍精度実数型変数で返します.
!>
!> `unit` には以下を与えることが可能です:
!> - dc_date_types#UNIT_DAY (日)
!> - dc_date_types#UNIT_HOUR (時)
!> - dc_date_types#UNIT_MIN (分)
!> - dc_date_types#UNIT_SEC (秒)
!>
!> `unit_symbol` には以下を与えることが可能です:
!> - dc_date_types#UNIT_SYMBOL_DAY (日)
!> - dc_date_types#UNIT_SYMBOL_HOUR (時)
!> - dc_date_types#UNIT_SYMBOL_MIN (分)
!> - dc_date_types#UNIT_SYMBOL_SEC (秒)
!>
!> これらに該当しないものを与えた場合, または引数を両方とも与えない場合,
!> 0.0 が返ります.
!>
!> @param[in] time 変換する DC_DATETIME 型変数
!> @param[in] unit 単位文字列
!> @param[in] unit_symbol 単位記号定数 (省略可能)
!> @return 変換された値 (倍精度実数型)
!> @endja
function dcdatetimeevalbyunit(time, unit, unit_symbol) result(result)
  use dc_types, only: dp
  use dc_date_generic, only: evalsec, evalmin, evalhour, evalday, parsetimeunits
  use dc_date_types, only: dc_datetime, &
    & unit_symbol_day, unit_symbol_hour, unit_symbol_min, unit_symbol_sec, &
    & unit_symbol_err
  implicit none
  real(dp):: result
  type(dc_datetime), intent(in):: time
  character(*), intent(in):: unit
  integer, intent(in), optional:: unit_symbol
  integer:: symbol
continue
  symbol = unit_symbol_err
  if ( present(unit_symbol) ) then
    symbol = unit_symbol
  else
    symbol = parsetimeunits(unit)
  end if
 
  if ( symbol == unit_symbol_sec ) then
    result = evalsec(time)
  elseif ( symbol == unit_symbol_min ) then
    result = evalmin(time)
  elseif ( symbol == unit_symbol_hour ) then
    result = evalhour(time)
  elseif ( symbol == unit_symbol_day ) then
    result = evalday(time)
  else
    result = 0.0_dp
  end if
end function dcdatetimeevalbyunit
 
 
!> @en
!> @brief Convert DC_DIFFTIME by specified unit
!> @details
!> Converts DC_DIFFTIME variable to the specified unit and returns
!> as double precision real.
!>
!> For `unit`, the following values can be specified:
!> - dc_date_types#UNIT_DAY (day)
!> - dc_date_types#UNIT_HOUR (hour)
!> - dc_date_types#UNIT_MIN (minute)
!> - dc_date_types#UNIT_SEC (second)
!> - dc_date_types#UNIT_NONDIM (nondimensional)
!>
!> For `unit_symbol`, the following values can be specified:
!> - dc_date_types#UNIT_SYMBOL_DAY (day)
!> - dc_date_types#UNIT_SYMBOL_HOUR (hour)
!> - dc_date_types#UNIT_SYMBOL_MIN (minute)
!> - dc_date_types#UNIT_SYMBOL_SEC (second)
!> - dc_date_types#UNIT_SYMBOL_NONDIM (nondimensional)
!>
!> Returns 0.0 if invalid unit is specified or neither argument is given.
!>
!> @param[in] diff DC_DIFFTIME variable to convert
!> @param[in] unit Unit string
!> @param[in] unit_symbol Unit symbol constant (optional)
!> @return Converted value as double precision real
!> @enden
!>
!> @ja
!> @brief DC_DIFFTIME を指定単位で変換
!> @details
!> DC_DIFFTIME 型変数の日時を `unit` の単位に換算して
!> 倍精度実数型変数で返します.
!>
!> `unit` には以下を与えることが可能です:
!> - dc_date_types#UNIT_DAY (日)
!> - dc_date_types#UNIT_HOUR (時)
!> - dc_date_types#UNIT_MIN (分)
!> - dc_date_types#UNIT_SEC (秒)
!> - dc_date_types#UNIT_NONDIM (無次元時間)
!>
!> `unit_symbol` には以下を与えることが可能です:
!> - dc_date_types#UNIT_SYMBOL_DAY (日)
!> - dc_date_types#UNIT_SYMBOL_HOUR (時)
!> - dc_date_types#UNIT_SYMBOL_MIN (分)
!> - dc_date_types#UNIT_SYMBOL_SEC (秒)
!> - dc_date_types#UNIT_SYMBOL_NONDIM (無次元時間)
!>
!> これらに該当しないものを与えた場合, または引数を両方とも与えない場合,
!> 0.0 が返ります.
!>
!> @param[in] diff 変換する DC_DIFFTIME 型変数
!> @param[in] unit 単位文字列
!> @param[in] unit_symbol 単位記号定数 (省略可能)
!> @return 変換された値 (倍精度実数型)
!> @endja
function dcdifftimeevalbyunit(diff, unit, unit_symbol) result(result)
  use dc_types, only: dp
  use dc_date_generic, only: evalnondim, evalsec, evalmin, evalhour, evalday, &
    & parsetimeunits
  use dc_date_types, only: dc_difftime, &
    & unit_symbol_day, unit_symbol_hour, unit_symbol_min, &
    & unit_symbol_sec, unit_symbol_nondim, unit_symbol_err
  implicit none
  real(dp):: result
  type(dc_difftime), intent(in):: diff
  character(*), intent(in):: unit
  integer, intent(in), optional:: unit_symbol
  integer:: symbol
continue
  symbol = unit_symbol_err
  if ( present(unit_symbol) ) then
    symbol = unit_symbol
  else
    symbol = parsetimeunits(unit)
  end if
 
  if ( symbol == unit_symbol_nondim ) then
    result = evalnondim(diff)
  elseif ( symbol == unit_symbol_sec ) then
    result = evalsec(diff)
  elseif ( symbol == unit_symbol_min ) then
    result = evalmin(diff)
  elseif ( symbol == unit_symbol_hour ) then
    result = evalhour(diff)
  elseif ( symbol == unit_symbol_day ) then
    result = evalday(diff)
  else
    result = 0.0_dp
  end if
end function dcdifftimeevalbyunit
 
 
 
!!$subroutine DCDateTimeEval0(time, mon, day, sec)
!!$  !
!!$  ! dc_date_types#DC_DATETIME 型変数の *time* を
!!$  ! 月 *mon*, 日 *day*, 秒 *sec* に変換して返す.
!!$  !
!!$  use dc_types, only: DP
!!$  use dc_date_types, only: DC_DATETIME, &
!!$    & CYCLIC_MDAYS, CAL_NOLEAP, CAL_JULIAN, CAL_CYCLIC, &
!!$    & FOUR_YEARS, FOUR_CENTURY
!!$  use dc_trace, only: BeginSub, EndSub
!!$  implicit none
!!$  type(DC_DATETIME), intent(in):: time
!!$  integer, intent(out):: mon, day
!!$  real(DP), intent(out):: sec
!!$  integer:: year, month
!!$  character(*), parameter :: subname = 'DCDateTimeEval0'
!!$continue
!!$  call BeginSub(subname)
!!$  sec = time%sec
!!$  if (time % caltype == CAL_CYCLIC) then
!!$    day = modulo(dble(time%day - 1), CYCLIC_MDAYS) + 1
!!$    mon = (time%day - 1) / CYCLIC_MDAYS
!!$    goto 999
!!$  endif
!!$  if (time % caltype == CAL_NOLEAP) then
!!$    day = modulo(time%day - 91, 365)
!!$    year = (time%day - 91 - day) / 365
!!$  else
!!$    if (time % caltype == CAL_JULIAN .or. time%day < 640196) then
!!$      day = modulo(time%day - 92, FOUR_YEARS)
!!$      year = (time%day - 92 - day) / FOUR_YEARS * 4
!!$    else
!!$      day = modulo(time%day - 94, FOUR_CENTURY)
!!$      year = (time%day - 94 - day) / FOUR_CENTURY * 400
!!$      if (day == FOUR_CENTURY - 1) then
!!$        year = year + 300
!!$        day = 36525
!!$      else
!!$        year = year + day / 36524 * 100
!!$        day = modulo(day, 36524)
!!$      endif
!!$      year = year + day / FOUR_YEARS * 4
!!$      day = modulo(day, FOUR_YEARS)
!!$    endif
!!$    if (day == FOUR_YEARS - 1) then
!!$      year = year + 3
!!$      day = 365
!!$    else
!!$      year = year + day / 365
!!$      day = modulo(day, 365)
!!$    endif
!!$  endif
!!$  day = day * 10 + 922
!!$  month = day / 306
!!$  mon = mod(month - 1, 12) + 1
!!$  year = year + (month - mon) / 12
!!$  day = mod(day, 306) / 10  + 1
!!$999 continue
!!$  call EndSub(subname, 'mon=<%d>, day=<%d>, sec=<%f>',&
!!$    & i=(/mon, day/), d=(/sec/))
!!$end subroutine DCDateTimeEval0