dcdatetimemul.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 Functions for user defined operation (*)
!> @details
!> This file contains implementation procedures of multiplication
!> for dc_date_types#DC_DIFFTIME.
!> @enden
!>
!> @ja
!> @brief 利用者定義演算子 (*) のための関数
!> @details
!> このファイルには dc_date_types#DC_DIFFTIME の乗算の実装手続きが
!> 含まれています。
!> @endja
!>
 
!> @en
!> @brief Multiply integer by DC_DIFFTIME
!> @details
!> Return the result of multiplying time difference `diff` by `factor`.
!>
!> @param[in] factor Integer multiplier
!> @param[in] diff   Time difference to multiply
!> @return Result of multiplication
!> @enden
!>
!> @ja
!> @brief 整数と DC_DIFFTIME の乗算
!> @details
!> 日時差 `diff` と `factor` とを乗算した結果を返します.
!>
!> @param[in] factor 整数の乗数
!> @param[in] diff   乗算する日時差
!> @return 乗算結果
!> @endja
function dcdatetime_mul_if(factor, diff) result(result)
 
  use dc_date_types, only: dc_datetime, dc_difftime
  use dc_date_internal, only: dcdate_normalize
  use dc_scaledsec, only: operator(*)
  implicit none
  type(dc_difftime):: result
  integer, intent(in):: factor
  type(dc_difftime), intent(in):: diff
continue
  result % mon = factor * diff % mon
  result % day = factor * diff % day
  result % sec = factor * diff % sec
  result % day_seconds = diff % day_seconds
  result % nondim_flag = diff % nondim_flag
  call dcdate_normalize(result % day, result % sec, result % day_seconds, result % nondim_flag)
end function dcdatetime_mul_if
 
!> @en
!> @brief Multiply DC_DIFFTIME by integer
!> @details
!> Return the result of multiplying time difference `diff` by `factor`.
!>
!> @param[in] diff   Time difference to multiply
!> @param[in] factor Integer multiplier
!> @return Result of multiplication
!> @enden
!>
!> @ja
!> @brief DC_DIFFTIME と整数の乗算
!> @details
!> 日時差 `diff` と `factor` とを乗算した結果を返します.
!>
!> @param[in] diff   乗算する日時差
!> @param[in] factor 整数の乗数
!> @return 乗算結果
!> @endja
function dcdatetime_mul_fi(diff, factor) result(result)
 
  use dc_date_generic, only: operator(*)
  use dc_date_types, only: dc_datetime, dc_difftime
  implicit none
  type(dc_difftime):: result
  type(dc_difftime), intent(in):: diff
  integer, intent(in):: factor
continue
  result = factor * diff
end function dcdatetime_mul_fi
 
!> @en
!> @brief Multiply single precision by DC_DIFFTIME
!> @details
!> Return the result of multiplying time difference `diff` by `factor`.
!>
!> @note Multiplying months by non-integer may produce approximate results.
!>
!> @param[in] factor Single precision multiplier
!> @param[in] diff   Time difference to multiply
!> @return Result of multiplication
!> @enden
!>
!> @ja
!> @brief 単精度実数と DC_DIFFTIME の乗算
!> @details
!> 日時差 `diff` と `factor` とを乗算した結果を返します.
!>
!> @note 月差を非整数倍すると近似的結果になるおそれがあります
!>
!> @param[in] factor 単精度実数の乗数
!> @param[in] diff   乗算する日時差
!> @return 乗算結果
!> @endja
function dcdatetime_mul_rf(factor, diff) result(result)
 
  use dc_date_generic, only: operator(*)
  use dc_date_types, only: dc_datetime, dc_difftime
  use dc_types, only: dp
  implicit none
  type(dc_difftime):: result
  real, intent(in):: factor
  type(dc_difftime), intent(in):: diff
continue
  result = real(factor, dp) * diff
end function dcdatetime_mul_rf
 
!> @en
!> @brief Multiply DC_DIFFTIME by single precision
!> @details
!> Return the result of multiplying time difference `diff` by `factor`.
!>
!> @note Multiplying months by non-integer may produce approximate results.
!>
!> @param[in] diff   Time difference to multiply
!> @param[in] factor Single precision multiplier
!> @return Result of multiplication
!> @enden
!>
!> @ja
!> @brief DC_DIFFTIME と単精度実数の乗算
!> @details
!> 日時差 `diff` と `factor` とを乗算した結果を返します.
!>
!> @note 月差を非整数倍すると近似的結果になるおそれがあります
!>
!> @param[in] diff   乗算する日時差
!> @param[in] factor 単精度実数の乗数
!> @return 乗算結果
!> @endja
function dcdatetime_mul_fr(diff, factor) result(result)
 
  use dc_date_generic, only: operator(*)
  use dc_date_types, only: dc_datetime, dc_difftime
  implicit none
  type(dc_difftime):: result
  type(dc_difftime), intent(in):: diff
  real, intent(in):: factor
continue
  result = factor * diff
end function dcdatetime_mul_fr
 
!> @en
!> @brief Multiply double precision by DC_DIFFTIME
!> @details
!> Return the result of multiplying time difference `diff` by `factor`.
!>
!> @note Multiplying months by non-integer may produce approximate results.
!>
!> @param[in] factor Double precision multiplier
!> @param[in] diff   Time difference to multiply
!> @return Result of multiplication
!> @enden
!>
!> @ja
!> @brief 倍精度実数と DC_DIFFTIME の乗算
!> @details
!> 日時差 `diff` と `factor` とを乗算した結果を返します.
!>
!> @note 月差を非整数倍すると近似的結果になるおそれがあります
!>
!> @param[in] factor 倍精度実数の乗数
!> @param[in] diff   乗算する日時差
!> @return 乗算結果
!> @endja
function dcdatetime_mul_df(factor, diff) result(result)
 
  use dc_date_internal, only: dcdate_normalize
  use dc_date_types, only: cyclic_mdays, dc_datetime, dc_difftime
  use dc_scaledsec, only: dc_scaled_sec, &
    & operator(<), operator(>), operator(<=), operator(>=), &
    & operator(+), operator(-), operator(*), operator(/), &
    & modulo, int, abs, sign
  use dc_types, only: dp
  implicit none
  type(dc_difftime):: result
  real(dp), intent(in):: factor
  type(dc_difftime), intent(in):: diff
  type(dc_scaled_sec):: month, day
continue
  month = factor * diff % mon
  result % mon = int(month)
  day = factor * diff % day + int(cyclic_mdays * (month - result % mon))
  result % day = int(day)
  result % sec = &
    & factor * diff % sec + (day - result % day) * diff % day_seconds
  result % day_seconds = diff % day_seconds
  result % nondim_flag = diff % nondim_flag
  call dcdate_normalize(result % day, result % sec, result % day_seconds, result % nondim_flag)
end function dcdatetime_mul_df
 
!> @en
!> @brief Multiply DC_DIFFTIME by double precision
!> @details
!> Return the result of multiplying time difference `diff` by `factor`.
!>
!> @note Multiplying months by non-integer may produce approximate results.
!>
!> @param[in] diff   Time difference to multiply
!> @param[in] factor Double precision multiplier
!> @return Result of multiplication
!> @enden
!>
!> @ja
!> @brief DC_DIFFTIME と倍精度実数の乗算
!> @details
!> 日時差 `diff` と `factor` とを乗算した結果を返します.
!>
!> @note 月差を非整数倍すると近似的結果になるおそれがあります
!>
!> @param[in] diff   乗算する日時差
!> @param[in] factor 倍精度実数の乗数
!> @return 乗算結果
!> @endja
function dcdatetime_mul_fd(diff, factor) result(result)
 
  use dc_date_generic, only: operator(*)
  use dc_date_types, only: dc_datetime, dc_difftime
  use dc_types, only: dp
  implicit none
  type(dc_difftime):: result
  type(dc_difftime), intent(in):: diff
  real(dp), intent(in):: factor
continue
  result = factor * diff
end function dcdatetime_mul_fd