dc_calendar_generic.f90

Go to the documentation of this file.

!-----------------------------------------------------------------------
! Copyright (c) 2000-2026 Gtool Development Group. All rights reserved.
!-----------------------------------------------------------------------
 
module dc_calendar_generic
 
  implicit none
 
  interface dccalcreate
    subroutine dccalcreate1( cal_type, cal, err )
      use dc_calendar_types, only: dc_cal
      character(*), intent(in):: cal_type
      type(dc_cal), intent(out), optional, target:: cal
      logical, intent(out), optional:: err
    end subroutine dccalcreate1
 
    subroutine dccalcreate2( month_in_year, day_in_month, &
      &                      hour_in_day, min_in_hour, sec_in_min, &
      &                      cal, err )
      use dc_calendar_types, only: dc_cal
      use dc_types, only: dp
      integer, intent(in):: month_in_year
      integer, intent(in):: day_in_month(:)
      integer, intent(in):: hour_in_day, min_in_hour
      real(DP), intent(in):: sec_in_min
      type(dc_cal), intent(out), optional, target:: cal
      logical, intent(out), optional:: err
    end subroutine dccalcreate2
  end interface
 
  interface dccaldefault
    subroutine dccaldefault1( cal )
      use dc_calendar_types, only: dc_cal
      type(dc_cal), intent(out):: cal
    end subroutine dccaldefault1
  end interface
 
  interface dccalinquire
    subroutine dccalinquire1( cal_type, &
      &                       month_in_year, &
      &                       day_in_month, day_in_month_ptr, &
      &                       hour_in_day, min_in_hour, sec_in_min, &
      &                       cal, err )
      use dc_calendar_types, only: dc_cal
      use dc_types, only: dp
      character(*), intent(out), optional:: cal_type
      integer, intent(out), optional:: month_in_year
      integer, intent(out), optional:: day_in_month(:)
      integer, pointer, optional:: day_in_month_ptr(:)
      integer, intent(out), optional:: hour_in_day, min_in_hour
      real(DP), intent(out), optional:: sec_in_min
      type(dc_cal), intent(in), optional, target:: cal
      logical, intent(out), optional:: err
    end subroutine dccalinquire1
  end interface
 
  interface dccaltochar
    function dccaltochar1( cal ) result(result)
      use dc_calendar_types, only: dc_cal
      use dc_types, only: string
      character(STRING):: result
      type(dc_cal), intent(in):: cal
    end function dccaltochar1
  end interface
 
  interface dccalconvertbyunit
    function dccalconvertbyunit1( in_time, in_unit, out_unit, cal ) result( out_time )
      use dc_calendar_types, only: dc_cal
      use dc_types, only: dp
      real(dp):: out_time
      real(dp), intent(in):: in_time
      character(*), intent(in):: in_unit
      character(*), intent(in):: out_unit
      type(dc_cal), intent(in), optional, target:: cal
    end function dccalconvertbyunit1
 
    function dccalconvertbyunit2( in_time, in_unit, out_unit, cal ) result( out_time )
      use dc_calendar_types, only: dc_cal
      use dc_types, only: dp
      real(dp):: out_time
      real(dp), intent(in):: in_time
      integer, intent(in):: in_unit
      integer, intent(in):: out_unit
      type(dc_cal), intent(in), optional, target:: cal
    end function dccalconvertbyunit2
  end interface
 
  interface dccalconverttosec
 
    function dccalconverttosec1( in_time, in_unit, cal ) result( out_time )
      use dc_calendar_types, only: dc_cal
      use dc_types, only: dp
      real(dp):: out_time
      real(dp), intent(in):: in_time
      character(*), intent(in):: in_unit
      type(dc_cal), intent(in), optional, target:: cal
    end function dccalconverttosec1
 
    function dccalconverttosec2( in_time, in_unit, cal ) result( out_time )
      use dc_calendar_types, only: dc_cal
      use dc_types, only: dp
      real(dp):: out_time
      real(dp), intent(in):: in_time
      integer, intent(in):: in_unit
      type(dc_cal), intent(in), optional, target:: cal
    end function dccalconverttosec2
 
  end interface
 
  interface dccalconverttomin
 
    function dccalconverttomin1( in_time, in_unit, cal ) result( out_time )
      use dc_calendar_types, only: dc_cal
      use dc_types, only: dp
      real(dp):: out_time
      real(dp), intent(in):: in_time
      character(*), intent(in):: in_unit
      type(dc_cal), intent(in), optional, target:: cal
    end function dccalconverttomin1
 
    function dccalconverttomin2( in_time, in_unit, cal ) result( out_time )
      use dc_calendar_types, only: dc_cal
      use dc_types, only: dp
      real(dp):: out_time
      real(dp), intent(in):: in_time
      integer, intent(in):: in_unit
      type(dc_cal), intent(in), optional, target:: cal
    end function dccalconverttomin2
 
  end interface
 
  interface dccalconverttohour
 
    function dccalconverttohour1( in_time, in_unit, cal ) result( out_time )
      use dc_calendar_types, only: dc_cal
      use dc_types, only: dp
      real(dp):: out_time
      real(dp), intent(in):: in_time
      character(*), intent(in):: in_unit
      type(dc_cal), intent(in), optional, target:: cal
    end function dccalconverttohour1
 
    function dccalconverttohour2( in_time, in_unit, cal ) result( out_time )
      use dc_calendar_types, only: dc_cal
      use dc_types, only: dp
      real(dp):: out_time
      real(dp), intent(in):: in_time
      integer, intent(in):: in_unit
      type(dc_cal), intent(in), optional, target:: cal
    end function dccalconverttohour2
 
  end interface
 
  interface dccalconverttoday
 
    function dccalconverttoday1( in_time, in_unit, cal ) result( out_time )
      use dc_calendar_types, only: dc_cal
      use dc_types, only: dp
      real(dp):: out_time
      real(dp), intent(in):: in_time
      character(*), intent(in):: in_unit
      type(dc_cal), intent(in), optional, target:: cal
    end function dccalconverttoday1
 
    function dccalconverttoday2( in_time, in_unit, cal ) result( out_time )
      use dc_calendar_types, only: dc_cal
      use dc_types, only: dp
      real(dp):: out_time
      real(dp), intent(in):: in_time
      integer, intent(in):: in_unit
      type(dc_cal), intent(in), optional, target:: cal
    end function dccalconverttoday2
 
  end interface
 
  interface dccalparseunit
    subroutine dccalparseunit1( unit_str, unit_sym, err )
      character(*), intent(in):: unit_str
      integer, intent(out):: unit_sym
      logical, intent(out), optional:: err
    end subroutine dccalparseunit1
  end interface
 
  interface dccaldatecreate
    subroutine dccaldatecreate1( year, month, day, hour, min, sec, date, zone, err )
      use dc_calendar_types, only: dc_cal_date
      use dc_types, only: dp
      integer, intent(in):: year, month, day, hour, min
      real(DP), intent(in):: sec
      type(dc_cal_date), intent(out), optional, target:: date
      character(*), intent(in), optional:: zone
      logical, intent(out), optional:: err
    end subroutine dccaldatecreate1
 
    subroutine dccaldatecreate2( date_str, date, err )
      use dc_calendar_types, only: dc_cal_date
      character(*), intent(in):: date_str
      type(dc_cal_date), intent(out), optional, target:: date
      logical, intent(out), optional:: err
    end subroutine dccaldatecreate2
  end interface
 
  interface dccaldatecurrent
    subroutine dccaldatecurrent1( date, err )
      use dc_calendar_types, only: dc_cal_date
      type(dc_cal_date), intent(out):: date
      logical, intent(out), optional:: err
    end subroutine dccaldatecurrent1
  end interface
 
  interface dccaldateparsestr
    subroutine dccaldateparsestr1( date_str, &
      & year, month, day, hour, min, sec, zone, &
      & err )
      use dc_types, only: dp
      character(*), intent(in):: date_str
      integer, intent(out):: year, month, day, hour, min
      real(DP), intent(out):: sec
      character(*), intent(out):: zone
      logical, intent(out), optional:: err
    end subroutine dccaldateparsestr1
  end interface
 
  interface dccaldateinquire
    subroutine dccaldateinquire1( year, month, day, hour, min, sec, zone, &
      & elapse_sec, date, cal, err )
      use dc_calendar_types, only: dc_cal_date, dc_cal
      use dc_types, only: dp
      integer, intent(out), optional:: year, month, day, hour, min
      real(DP), intent(out), optional:: sec
      character(*), intent(out), optional:: zone
      real(DP), intent(in), optional:: elapse_sec
      type(dc_cal_date), intent(in), optional, target:: date
      type(dc_cal), intent(in), optional, target:: cal
      logical, intent(out), optional:: err
    end subroutine dccaldateinquire1
 
    subroutine dccaldateinquire2( date_str, elapse_sec, date, cal, err )
      use dc_types, only: dp
      use dc_calendar_types, only: dc_cal_date, dc_cal
      character(*), intent(out):: date_str
      real(DP), intent(in), optional:: elapse_sec
      type(dc_cal_date), intent(in), optional, target:: date
      type(dc_cal), intent(in), optional, target:: cal
      logical, intent(out), optional:: err
    end subroutine dccaldateinquire2
  end interface
 
  interface dccaldatetochar
    function dccaldatetochar1( year, month, day, hour, min, sec, zone ) &
      & result(result)
      use dc_types, only: string, dp, token
      character(STRING):: result
      integer, intent(in):: year, month, day, hour, min
      real(dp), intent(in):: sec
      character(*), intent(in), optional:: zone
    end function dccaldatetochar1
  end interface
 
  interface dccaldateeval
    subroutine dccaldateevalymdhms1( year, month, day, hour, min, sec, elapse_sec, cal, date, err )
      use dc_calendar_types, only: dc_cal, dc_cal_date
      use dc_types, only: dp
      integer, intent(in):: year, month, day, hour, min
      real(DP), intent(in):: sec, elapse_sec
      type(dc_cal), intent(in), optional, target:: cal
      type(dc_cal_date), intent(out), optional, target:: date
      logical, intent(out), optional:: err
    end subroutine dccaldateevalymdhms1
 
    subroutine dccaldateevalymdhms2( year, month, day, hour, min, sec, elapse_time, units, cal, date, err )
      use dc_calendar_types, only: dc_cal, dc_cal_date
      use dc_types, only: dp
      integer, intent(in):: year, month, day, hour, min
      real(DP), intent(in):: sec, elapse_time
      character(*), intent(in):: units
      type(dc_cal), intent(in), optional, target:: cal
      type(dc_cal_date), intent(out), optional, target:: date
      logical, intent(out), optional:: err
    end subroutine dccaldateevalymdhms2
 
    subroutine dccaldateevalid1( init_date, elapse_sec, cal, date, err )
      use dc_calendar_types, only: dc_cal, dc_cal_date
      use dc_types, only: dp
      type(dc_cal_date), intent(in):: init_date
      real(DP), intent(in):: elapse_sec
      type(dc_cal), intent(in), optional, target:: cal
      type(dc_cal_date), intent(out), optional, target:: date
      logical, intent(out), optional:: err
    end subroutine dccaldateevalid1
 
    subroutine dccaldateevalid2( init_date, elapse_time, units, cal, date, err )
      use dc_calendar_types, only: dc_cal, dc_cal_date
      use dc_types, only: dp
      type(dc_cal_date), intent(in):: init_date
      real(DP), intent(in):: elapse_time
      character(*), intent(in):: units
      type(dc_cal), intent(in), optional, target:: cal
      type(dc_cal_date), intent(out), optional, target:: date
      logical, intent(out), optional:: err
    end subroutine dccaldateevalid2
 
    subroutine dccaldateevalym2ym1( &
      & year1, month1, day1, hour1, min1, sec1, &
      & elapse_sec, &
      & year2, month2, day2, hour2, min2, sec2, &
      & cal, err )
      use dc_calendar_types, only: dc_cal_date, dc_cal
      use dc_types, only: dp
      integer, intent(in):: year1, month1, day1, hour1, min1
      real(DP), intent(in):: sec1, elapse_sec
      integer, intent(out):: year2, month2, day2, hour2, min2
      real(DP), intent(out):: sec2
      type(dc_cal), intent(in), optional, target:: cal
      logical, intent(out), optional:: err
    end subroutine dccaldateevalym2ym1
 
    subroutine dccaldateevalym2ym2( &
      & year1, month1, day1, hour1, min1, sec1, &
      & elapse_time, units, &
      & year2, month2, day2, hour2, min2, sec2, &
      & cal, err )
      use dc_calendar_types, only: dc_cal_date, dc_cal
      use dc_types, only: dp
      integer, intent(in):: year1, month1, day1, hour1, min1
      real(DP), intent(in):: sec1, elapse_time
      character(*), intent(in):: units
      integer, intent(out):: year2, month2, day2, hour2, min2
      real(DP), intent(out):: sec2
      type(dc_cal), intent(in), optional, target:: cal
      logical, intent(out), optional:: err
    end subroutine dccaldateevalym2ym2
 
  end interface
 
  interface dccaldatedifference
    function dccaldatedifference1( start_date, end_date, cal ) result(sec)
      use dc_calendar_types, only: dc_cal_date, dc_cal
      use dc_types, only: dp
      type(dc_cal_date), intent(in):: start_date, end_date
      type(dc_cal), intent(in), optional, target:: cal
      real(dp):: sec
    end function dccaldatedifference1
  end interface
 
  interface dccaldateevalsecofyear
    function dccaldateevalsecofyear1( elapse_sec, date, cal ) result(result)
      use dc_calendar_types, only: dc_cal_date, dc_cal
      use dc_types, only: dp
      real(dp), intent(in):: elapse_sec
      type(dc_cal_date), intent(in), optional, target:: date
      type(dc_cal), intent(in), optional, target:: cal
      real(dp):: result
    end function dccaldateevalsecofyear1
  end interface
 
  interface dccaldateevaldayofyear
    function dccaldateevaldayofyear1( elapse_sec, date, cal ) result(result)
      use dc_calendar_types, only: dc_cal_date, dc_cal
      use dc_types, only: dp
      real(dp), intent(in):: elapse_sec
      type(dc_cal_date), intent(in), optional, target:: date
      type(dc_cal), intent(in), optional, target:: cal
      real(dp):: result
    end function dccaldateevaldayofyear1
  end interface
 
  interface dccaldateevalsecofday
    function dccaldateevalsecofday1( elapse_sec, date, cal ) result(result)
      use dc_calendar_types, only: dc_cal_date, dc_cal
      use dc_types, only: dp
      real(dp), intent(in):: elapse_sec
      type(dc_cal_date), intent(in), optional, target:: date
      type(dc_cal), intent(in), optional, target:: cal
      real(dp):: result
    end function dccaldateevalsecofday1
  end interface
 
  interface dccaldatechkleapyear
    function dccaldatechkleapyear1( elapse_sec, date, cal ) result(result)
      use dc_calendar_types, only: dc_cal_date, dc_cal
      use dc_types, only: dp
      real(dp), intent(in):: elapse_sec
      type(dc_cal_date), intent(in), optional, target:: date
      type(dc_cal), intent(in), optional, target:: cal
      logical:: result
    end function dccaldatechkleapyear1
  end interface
 
end module dc_calendar_generic