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.
!-----------------------------------------------------------------------
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