source: tags/libIGCM_v1_12/libIGCM_date/libIGCM_date.ksh

#!/bin/ksh

#**************************************************************
# Author: Sebastien Denvil
# Contact: Sebastien.Denvil__at__ipsl.jussieu.fr
# $Revision::                                          $ Revision of last commit
# $Author::                                            $ Author of last commit
# $Date::                                              $ Date of last commit
# IPSL (2006)
#  This software is governed by the CeCILL licence see libIGCM/libIGCM_CeCILL.LIC
#
#**************************************************************

#==================================================
# The documentation of this file can be automatically generated
# if you use the prefix #D- for comments to be extracted.
# Extract with command: cat lib* | grep "^#D-" | cut -c "4-"
#==================================================

#D-#==================================================================
#D-libIGCM_date
#D-This ksh library handles date calculs and convertions in different calendars.
#D-  types of calendars are possible :
#D-
#D-  - leap|gregorian|standard (other name leap) :
#D-      The normal calendar. The time origin for the
#D-      julian day in this case is 24 Nov -4713.
#D-  - noleap|365_day :
#D-      A 365 day year without leap years.
#D-  - all_leap|366_day :
#D-      A 366 day year with only leap years.
#D-  - 360d|360_day :
#D-      Year of 360 days with month of equal length.

# Number of digit in the year
typeset -r dY=${dY:=4}
#typeset -r MaxpY=$( echo "10^"$((dY+1)) | bc -l )
# Number of digit in non-human date representation
typeset -r pY=$(( dY+4 ))

#==================================================================
function IGCM_date_YearDigit
{
    IGCM_debug_PushStack "IGCM_date_YearDigit" $@

    NUM=$(( 10#${1} ))
    echo $( gawk "BEGIN { printf \"%0${dY}d\",${NUM} }" )

    IGCM_debug_PopStack "IGCM_date_YearDigit"
}

#==================================================================
function IGCM_date_GregorianDigit
{
    IGCM_debug_PushStack "IGCM_date_GregorianDigit" $@

    NUM=$(( 10#${1} ))
    echo $( gawk "BEGIN { printf \"%0${pY}d\",${NUM} }" )

    IGCM_debug_PopStack "IGCM_date_GregorianDigit"
}

#==================================================================
function IGCM_date_HumanDigit
{
    IGCM_debug_PushStack "IGCM_date_HumanDigit" $@

    echo $( IGCM_date_GregorianDigit $( print ${1} | sed 's/-//g' ) ) \
        | sed -e "s/\([0-9]\{${dY}\}\)\([0-9]\{2\}\)\([0-9]\{2\}\)/\1-\2-\3/"

    IGCM_debug_PopStack "IGCM_date_HumanDigit"
}

#==================================================================
function IGCM_date_SupressZeros
{
    IGCM_debug_PushStack "IGCM_date_SupressZeros" $@
    echo $( print ${1} | sed -e "s/0*//" )
    IGCM_debug_PopStack "IGCM_date_SupressZeros"
}

#==================================================================
function IGCM_date_ConvertFormatToGregorian
{
    IGCM_debug_PushStack "IGCM_date_ConvertFormatToGregorian" $@

    # from a yyyy-mm-dd date format return 
    # a yyymmdd date format
    # usage IGCM_date_ConvertFormat yyyy-mm-dd

    # if there is no argument on the command line, 
    # then assume that a y-m-d formated date is being 
    # piped in
    typeset ymd
    if [ $# = 0 ]
        then
        read ymd
    else
        ymd=$1
    fi

    IGCM_date_GregorianDigit $( print ${ymd} | sed 's/-//g' )

    IGCM_debug_PopStack "IGCM_date_ConvertFormatToGregorian"
}

#==================================================================
function IGCM_date_ConvertFormatToHuman
{
    IGCM_debug_PushStack "IGCM_date_ConvertFormatToHuman" $@

    # from a yyyymmdd date format return 
    # a yyyy-mm-dd date format
    # usage IGCM_date_ConvertFormat yyyymmdd

    # if there is no argument on the command line, 
    # then assume that a yyyymmdd formated date is being 
    # piped in
    typeset dt
    if [ $# = 0 ]
        then
        read dt
    else
        dt=$1
    fi

    # break the yyyymmdd into separate parts for year, month and day
    echo $( IGCM_date_GregorianDigit ${dt} ) \
        | sed -e "s/\([0-9]\{${dY}\}\)\([0-9]\{2\}\)\([0-9]\{2\}\)/\1-\2-\3/"

    IGCM_debug_PopStack "IGCM_date_ConvertFormatToHuman"
}

#==================================================================
function IGCM_date_GetYearMonth
{
    IGCM_debug_PushStack "IGCM_date_GetYearMonth" $@

    # from a yyyymmdd date format return 
    # a yyyy year and mm month
    # usage IGCM_date_GetYearMonth yyyymmdd year_var month_var

    # if there is no argument on the command line, 
    # then assume that a yyyymmdd formated date is being 
    # piped in
    typeset dt
    if [ $# = 0 ]
        then
        read dt
    else
        dt=$1
    fi

    # break the yyyymmdd into separate parts for year, month and day
    eval $2=$( echo $( IGCM_date_GregorianDigit ${dt} ) \
        | sed -e "s/\([0-9]\{${dY}\}\)\([0-9]\{2\}\)\([0-9]\{2\}\)/\1/" )
    eval $3=$( echo $( IGCM_date_GregorianDigit ${dt} ) \
        | sed -e "s/\([0-9]\{${dY}\}\)\([0-9]\{2\}\)\([0-9]\{2\}\)/\2/" )

    IGCM_debug_PopStack "IGCM_date_GetYearMonth"
}

#==================================================================
function IGCM_date_GetYearMonthDay
{
    IGCM_debug_PushStack "IGCM_date_GetYearMonthDay" $@

    # from a yyyymmdd date format return 
    # a yyyy year, mm month and dd day
    # usage IGCM_date_GetYearMonthDay yyyymmdd year_var month_var day_var

    # if there is no argument on the command line, 
    # then assume that a yyyymmdd formated date is being 
    # piped in
    typeset dt
    if [ $# = 0 ]
        then
        read dt
    else
        dt=$1
    fi

    # break the yyyymmdd into separate parts for year, month and day
    eval $2=$( echo $( IGCM_date_GregorianDigit ${dt} ) \
        | sed -e "s/\([0-9]\{${dY}\}\)\([0-9]\{2\}\)\([0-9]\{2\}\)/\1/" )
    eval $3=$( echo $( IGCM_date_GregorianDigit ${dt} ) \
        | sed -e "s/\([0-9]\{${dY}\}\)\([0-9]\{2\}\)\([0-9]\{2\}\)/\2/" )
    eval $4=$( echo $( IGCM_date_GregorianDigit ${dt} ) \
        | sed -e "s/\([0-9]\{${dY}\}\)\([0-9]\{2\}\)\([0-9]\{2\}\)/\3/" )

    IGCM_debug_PopStack "IGCM_date_GetYearMonthDay"
}

#D-#==================================================================
#D-function IGCM_date_DaysInYear
#D-* Purpose: Return the number of days in a year
#D-* Usage: IGCM_date_DaysInYear yyyy
#D-         if there is no argument on the command line, 
#D-         then assume that a yyyy is being piped in
#D-
function IGCM_date_DaysInYear
{
#    IGCM_debug_PushStack "IGCM_date_DaysInYear" $@
    # return the number of days in a year
    # usage IGCM_date_DaysInYear yyyy

    # What is the calendar :
    case ${config_UserChoices_CalendarType} in
        360d|360_day)
            if [ X$2 = X ] ; then
                echo 360
            else
                eval $2=360 > /dev/null 2>&1
            fi
#       IGCM_debug_PopStack "IGCM_date_DaysInYear"
            return;;
        noleap|365_day)
            if [ X$2 = X ] ; then
                echo 365
            else
                eval $2=365 > /dev/null 2>&1
            fi

#           IGCM_debug_PopStack "IGCM_date_DaysInYear"
            return;;
        all_leap|366_day)
            if [ X$2 = X ] ; then
                echo 366
            else
                eval $2=366 > /dev/null 2>&1
            fi

#               IGCM_debug_PopStack "IGCM_date_DaysInYear"
            return;;
    esac

    typeset y a

    # if there is no argument on the command line, 
    # then assume that a yyyy is being piped in
    if [ $# = 0 ]
        then
        read y
    else
        y=$(( 10#${1} ))
    fi

    # a year is a leap year if it is even divisible by 4
    # but not evenly divisible by 100
    # unless it is evenly divisible by 400

    # if it is evenly divisible by 400 it must be a leap year
    a=$(( $y % 400 ))
    if [ $a = 0 ]
        then
        if [ X$2 = X ] ; then
            echo 366
        else
            eval $2=366 > /dev/null 2>&1
        fi

#       IGCM_debug_PopStack "IGCM_date_DaysInYear"
        return
    fi

    #if it is evenly divisible by 100 it must not be a leap year
    a=$(( $y % 100 ))
    if [ $a = 0 ]
        then
        if [ X$2 = X ] ; then
            echo 365
        else
            eval $2=365 > /dev/null 2>&1
        fi

#       IGCM_debug_PopStack "IGCM_date_DaysInYear"
        return
    fi
        
    # if it is evenly divisible by 4 it must be a leap year
    a=$(( $y % 4 ))
    if [ $a = 0 ]
        then
        if [ X$2 = X ] ; then
            echo 366
        else
            eval $2=366 > /dev/null 2>&1
        fi

#       IGCM_debug_PopStack "IGCM_date_DaysInYear"
        return
    fi

    # otherwise it is not a leap year
    if [ X$2 = X ] ; then
        echo 365
    else
        eval $2=365 > /dev/null 2>&1
    fi

#    IGCM_debug_PopStack "IGCM_date_DaysInYear"
}

#D-#==================================================================
#D-function IGCM_date_DaysInMonth
#D-* Purpose: Calculate the number of days in a month 
#D-* Usage: IGCM_date_DaysInMonth yyyy mm
#D-         or IGCM_date_DaysInMonth yyyymmdd
#D-         if there are no command line arguments then 
#D-         assume that a yyyymmdd is being piped in and read the value.
#D-         if there is only one argument assume it is a yyyymmdd on the command line
#D-         other wise it is a yyyy and mm on the command line
function IGCM_date_DaysInMonth
{
#    IGCM_debug_PushStack "IGCM_date_DaysInMonth" $@

    # calculates the number of days in a month 
    # usage IGCM_date_DaysInMonth yyyy mm
    # or IGCM_date_DaysInMonth yyyymmdd
    
    # What is the calendar :
    if ( [ "${config_UserChoices_CalendarType}" = "360d" ] || [ "${config_UserChoices_CalendarType}" = "360_day" ] ) ; then
        if [ X$3 = X ] ; then
            echo 30
        else
            eval $3=30 > /dev/null 2>&1
        fi

#       IGCM_debug_PopStack "IGCM_date_DaysInMonth"
        return
    fi

    typeset ymd y m

    # if there are no command line arguments then assume that a yyyymmdd is being
    # piped in and read the value.
    # if there is only one argument assume it is a yyyymmdd on the command line
    # other wise it is a yyyy and mm on the command line
    if [ $# = 0 ]
        then
        read ymd
    elif [ $# = 1 ] 
        then
        ymd=$1
    else
        ymd=$(( ( $1 * 10000 ) + ( $2 * 100 ) + 1 ))
    fi

    # extract the year and the month
    y=$(( $ymd / 10000 )) ;
    m=$(( ( $ymd % 10000 ) / 100 )) ;

    # 30 days hath september etc.
    case $m in
        1|3|5|7|8|10|12) 
            if [ X$3 = X ] ; then
                echo 31
            else
                eval $3=31 > /dev/null 2>&1
            fi

#           IGCM_debug_PopStack "IGCM_date_DaysInMonth"
            return ;;
        4|6|9|11) 
            if [ X$3 = X ] ; then
                echo 30
            else
                eval $3=30 > /dev/null 2>&1
            fi
        
#           IGCM_debug_PopStack "IGCM_date_DaysInMonth"
            return ;;
        *) ;;
    esac

    # except for month 2 which depends on whether the year is a leap year
    # Use IGCM_date_DaysInYear to get the number of days in the year and return a value
    # accordingly.
    IGCM_date_DaysInYear $y diy
    case $diy in
        365) 
            if [ X$3 = X ] ; then
                echo 28
            else
                eval $3=28 > /dev/null 2>&1
            fi

#           IGCM_debug_PopStack "IGCM_date_DaysInMonth"
            return ;;
        366) 
            if [ X$3 = X ] ; then
                echo 29
            else
                eval $3=29 > /dev/null 2>&1
            fi

#           IGCM_debug_PopStack "IGCM_date_DaysInMonth"
            return ;;
    esac

#    IGCM_debug_PopStack "IGCM_date_DaysInMonth"
}

#D-#==================================================================
#D-function IGCM_date_ConvertGregorianDateToJulian
#D-* Purpose: Convert yyyymmdd to yyyyddd
#D-* Usage: IGCM_date_ConvertGregorianDateToJulian 19980429
#D-         if there is no command line argument, then assume that the date
#D-         is coming in on a pipe and use read to collect it
#D-
function IGCM_date_ConvertGregorianDateToJulian
{
    IGCM_debug_PushStack "IGCM_date_ConvertGregorianDateToJulian" $@

    # IGCM_date_ConvertGregorianDateToJulian converts yyyymmdd to yyyyddd
    # usage IGCM_date_ConvertGregorianDateToJulian 19980429

    typeset dt y m d x jul

    # if there is no command line argument, then assume that the date
    # is coming in on a pipe and use read to collect it    
    if [ $# = 0 ]
        then
        read dt
    else
        dt=$( IGCM_date_SupressZeros $1 )
    fi

    # break the yyyymmdd into separate parts for year, month and day
    y=$(( $dt / 10000 ))
    m=$(( ( $dt % 10000 ) / 100 ))
    d=$(( ( $dt % 100 ) ))

    # add the days in each month up to (but not including the month itself)
    # into the days. For example if the date is 19980203 then extract the
    # number of days in January and add it to 03. If the date is June 14, 1998
    # then extract the number of days in January, February, March, April and May
    # and add them to 14.
    x=1
    while [ $x -lt $m ]
      do
      IGCM_date_DaysInMonth $y $x md
      d=$(( $d + $md ))
      x=$(( $x + 1 ))
    done

    # combine the year and day back together again and you have the julian date.
    jul=$(( ( $y * 1000 ) + $d ))
    echo $jul

    IGCM_debug_PopStack "IGCM_date_ConvertGregorianDateToJulian"
}

#D-#==================================================================
#D-function IGCM_date_ConvertJulianDateToGregorian()
#D-* Purpose: Convert yyyyddd to yyyymmdd
#D-* Usage: IGCM_date_ConvertJulianDateToGregorian 1998213
#D-         if there is no command line argument, assume one is being 
#D-         piped in and read it
#D-
function IGCM_date_ConvertJulianDateToGregorian
{
    IGCM_debug_PushStack "IGCM_date_ConvertJulianDateToGregorian" $@

    # IGCM_date_ConvertJulianDateToGregorian converts yyyyddd to yyyymmdd
    # usage IGCM_date_ConvertJulianDateToGregorian 1998213

    typeset dt y m d grg

    # if there is no command line argument, assume one is being 
    # piped in and read it
    if [ X$1 = X ]
        then
        read dt
    else
        dt=$1
    fi
        
    # break apart the year and the days
    y=$(( $dt / 1000 ))
    d=$(( $dt % 1000 ))
        
    # subtract the number of days in each month starting from 1
    # from the days in the date. When the day goes below 1, you
    # have the current month. Add back the number of days in the
    # month to get the correct day of the month
    m=1
    while [ $d -gt 0 ]
      do
      IGCM_date_DaysInMonth $y $m md
      d=$(( $d - $md ))
      m=$(( $m + 1 ))
    done

    d=$(( $d + $md ))

    # the loop steps one past the correct month, so back up the month
    m=$(( $m - 1 ))

    # assemble the results into a gregorian date
    grg=$(( ( $y * 10000 ) + ( $m * 100 ) + $d ))
    echo $( IGCM_date_GregorianDigit $grg )

    IGCM_debug_PopStack "IGCM_date_ConvertJulianDateToGregorian"
}

#D-#==================================================================
#D-function IGCM_date_AddDaysToJulianDate
#D-* Purpose: Add days to a yyyyddd formatted date
#D-* Usage: IGCM_date_AddDaysToJulianDate 1998312 { ,-}14
#D-         Read the difference from the command lines
#D-         and the date from the command line, or standard input
#D-
function IGCM_date_AddDaysToJulianDate
{
    IGCM_debug_PushStack "IGCM_date_AddDaysToJulianDate" $@

    # IGCM_date_AddDaysToJulianDate adds days to a yyyyddd formatted date
    # usage IGCM_date_AddDaysToJulianDate 1998312 { ,-}14

    typeset dif yd d y

    # Read the difference from the command lines
    # and the date from the command line, or standard input
    if [ X$2 = X ]
        then
        dif=$1
        read yd
    else
        yd=$1
        dif=$2
    fi

    # Break it into pieces
    d=$(( $yd % 1000 ))
    y=$(( $yd / 1000 ))

    # Add the number of days (if days is negative this results is
    # a subtraction)
    d=$(( $d + $dif ))

    # Extract the days in the year
    IGCM_date_DaysInYear $y diy

    # If the calculated day exceeds the days in the year, 
    # add one year to the year and subtract the days in the year from the
    # calculated days. Extract the days in the new year and repeat
    # test until you end up with a day number that falls within the
    # days of the year
    while [ $d -gt $diy ]
      do
      d=$(( $d - $diy ))
      y=$(( $y + 1 ))
      IGCM_date_DaysInYear $y diy
    done

    # This is the reverse process. If the calculated number of days
    # is less than 1, move back one year. Extract
    # the days in this year and add the days in the year
    # loop on this test until you end up with a number that
    # falls within the days of the year
    while [ $d -lt 1 ]
      do
      y=$(( $y - 1 ))
      IGCM_date_DaysInYear $y diy
      d=$(( $d + $diy ))
    done

    # put the year and day back together and echo the result
    yd=$(( ( $y * 1000 ) + $d ))

    echo $yd

    IGCM_debug_PopStack "IGCM_date_AddDaysToJulianDate"
}

#D-#==================================================================
#D-function IGCM_date_AddDaysToGregorianDate
#D-* Purpose: Add days to a yyyymmdd formatted date
#D-* Usage: IGCM_date_AddDaysToGregorianDate 19980312 { ,-}14
#D-         Read the difference from the command lines
#D-         and the date from the command line, or standard input
#D-
function IGCM_date_AddDaysToGregorianDate
{
    IGCM_debug_PushStack "IGCM_date_AddDaysToGregorianDate" $@

    # IGCM_date_AddDaysToGregorianDate adds days to a yyyymmdd formatted date
    # usage IGCM_date_AddDaysToGregorianDate 19980312 { ,-}14

    # Read the difference from the command lines
    # and the date from the command line, or standard input
    typeset dif yd tmp res
    if [ X$2 = X ]
        then
        dif=$1
        read yd
    else
        yd=$1
        dif=$2
    fi

    tmp=$( IGCM_date_ConvertGregorianDateToJulian $yd )
    tmp=$( IGCM_date_AddDaysToJulianDate $tmp $dif )
    res=$( IGCM_date_ConvertJulianDateToGregorian $tmp )
    
    echo $res

    IGCM_debug_PopStack "IGCM_date_AddDaysToGregorianDate"
}

#D-#==================================================================
#D-function IGCM_date_DaysBetweenJulianDate
#D-* Purpose: Calculate the days difference between two dates and reports 
#D-           the number days as jul1 - jul2 
#D-* Usage: IGCM_date_DaysBetweenJulianDate jul1 jul2
#D-         where julian date is in the form yyyyddd
#D-
function IGCM_date_DaysBetweenJulianDate
{
    IGCM_debug_PushStack "IGCM_date_DaysBetweenJulianDate" $@

    # calculates the days difference between two dates and reports 
    # the number days as jul1 - jul2 
    # usage IGCM_date_DaysBetweenJulianDate jul1 jul2
    # where julian date is in the form yyyyddd
    
    usage () {
        echo "Usage:"
        echo " IGCM_date_DaysBetweenJulianDate jul1 jul2"
        echo ""
        echo " Calculates the day difference between"
        echo " two julian dates (jul1 -jul2)"
        echo " where a julian date is in the form of yyyyddd."
    }
 
    if [ $# -lt 2 ]; then
        usage
        IGCM_debug_Exit "IGCM_date_DaysBetweenJulianDate"
    fi
 
    # This process subtracts arg2 from arg1. If arg2 is larger
    # then reverse the arguments. The calculations are done, and
    # then the sign is reversed
    if [ $1 -lt $2 ]
        then
        jul1=$2
        jul2=$1
    elif [ $1 -gt $2 ]
        then
        jul1=$1
        jul2=$2
    else
        echo 0
        IGCM_debug_PopStack "IGCM_date_DaysBetweenJulianDate"
        return
    fi

    # Break the dates in to year and day portions
    yyyy1=$(( $jul1 / 1000 ))
    yyyy2=$(( $jul2 / 1000 ))
    ddd1=$(( $jul1 % 1000 ))
    ddd2=$(( $jul2 % 1000 ))

    # Subtract days
    res=$(( $ddd1 - $ddd2 ))

    # Then add days in year until year2 matches year1

    case ${config_UserChoices_CalendarType} in
        360d|360_day) 
            res=$(( ( ( $yyyy1 - $yyyy2 ) * 360 ) + $res )) ;;
        noleap|365_day)
            res=$(( ( ( $yyyy1 - $yyyy2 ) * 365 ) + $res )) ;;
        all_leap|366_day)
            res=$(( ( ( $yyyy1 - $yyyy2 ) * 366 ) + $res )) ;;
        leap|gregorian|standard)
            while [ $yyyy2 -lt $yyyy1 ]
            do
                IGCM_date_DaysInYear $yyyy2 diy
                res=$(( $res + $diy ))
                yyyy2=$(( $yyyy2 + 1 ))
            done
            ;;
    esac


    # if argument 2 was larger than argument 1 then 
    # the arguments were reversed before calculating
    # adjust by reversing the sign
    if [ $1 -lt $2 ]
        then
        res=$(( $res * -1 ))
    fi
 
    # and output the results
    echo $res

    IGCM_debug_PopStack "IGCM_date_DaysBetweenJulianDate"
}

#D-#==================================================================
#D-function IGCM_date_DaysBetweenGregorianDate ()
#D-* Purpose: Calculate the days difference between two dates and reports 
#D-           the number days as grg1 - grg2 
#D-* Usage: IGCM_date_DaysBetweenGregorianDate grg1 grg2
#D-         where gregorian date is in the form yyyymmdd
#D-
function IGCM_date_DaysBetweenGregorianDate
{
    IGCM_debug_PushStack "IGCM_date_DaysBetweenGregorianDate" $@

    # calculates the days difference between two dates and reports 
    # the number days as grg1 - grg2 
    # usage IGCM_date_DaysBetweenGregorianDate grg1 grg2
    # where gregorian date is in the form yyyymmdd

    usage () {
        echo "Usage:"
        echo " IGCM_date_DaysBetweenGregorianDate grg1 grg2"
        echo ""
        echo " Calculate day difference between"
        echo " two gregorian dates (grg1 - grg2)"
        echo " where a gregorian date is in the form of yyyymmdd."
    }

    if [ $# -lt 2 ]; then
        usage
        IGCM_debug_Exit "IGCM_date_DaysBetweenGregorianDate"
    fi

    # convert each date to julian
    grg1=$1
    grg2=$2

    jul1=$( IGCM_date_ConvertGregorianDateToJulian $grg1 )
    jul2=$( IGCM_date_ConvertGregorianDateToJulian $grg2 )

    if [ $jul1 -ne $jul2 ]; then
    # calculate the answer using IGCM_date_DaysBetweenJulianDate
        res=$( IGCM_date_DaysBetweenJulianDate $jul1 $jul2 )
    # and output the results
        echo $res
    else
        echo 0
    fi

    IGCM_debug_PopStack "IGCM_date_DaysBetweenGregorianDate"
}

#D-#==================================================================
#D-function IGCM_date_DaysSinceJC ()
#D-* Purpose: Calculate the days difference between a date and 00010101
#D-* Usage: IGCM_date_DaysSinceJC grg1
#D-         where gregorian date is in the form yyyymmdd
#D-
function IGCM_date_DaysSinceJC
{
    IGCM_debug_PushStack "IGCM_date_DaysSinceJC" $@

    # calculates the days difference between a date and 00010101
    # usage IGCM_date_DaysSinceJC grg1
    # where gregorian date is in the form yyyymmdd

    usage () {
        echo "Usage:"
        echo " IGCM_date_DaysSinceJC grg1"
        echo ""
        echo " Calculate day difference between"
        echo " a gregorian date and 00010101"
        echo " where a gregorian date is in the form of yyyymmdd."
    }

    if [ $# -lt 1 ]; then
        usage
        IGCM_debug_Exit "IGCM_date_DaysSinceJC"
    fi
    
    typeset aux num

    if   [ ${1} -lt  5000000 ]; then
        case ${config_UserChoices_CalendarType} in
            360d|360_day) 
                aux=-360;;
            noleap|365_day)
                aux=-365;;
            all_leap|366_day) 
                aux=-366;;
            leap|gregorian|standard)
                aux=-366;;
        esac
        num=101
    elif [ ${1} -lt 15000000 ]; then
        # To save CPU type we use auxiliary value
        # which is number of days since JC and 10000101
        case ${config_UserChoices_CalendarType} in
            360d|360_day) 
                aux=359640;;
            noleap|365_day)
                aux=364635;;
            all_leap|366_day) 
                aux=365634;;
            leap|gregorian|standard)
                aux=364877;;
        esac
        num=10000101
    else
        # To save CPU type we use auxiliary value
        # which is number of days since JC and 19000101
        case ${config_UserChoices_CalendarType} in
            360d|360_day) 
                aux=683640;;
            noleap|365_day)
                aux=693135;;
            all_leap|366_day) 
                aux=695034;;
            leap|gregorian|standard)
                aux=693595;;
        esac
        num=19000101
    fi
    echo $(( $( IGCM_date_DaysBetweenGregorianDate $1 ${num} ) + $aux ))

    IGCM_debug_PopStack "IGCM_date_DaysSinceJC"
}

#D-#==================================================================
#D-function IGCM_date_Check
#D- * Purpose: Check the present file by comparison with a reference file
function IGCM_date_Check
{
    IGCM_debug_PushStack "IGCM_date_Check"

#---------------------
    if [ ! -n "${libIGCM}" ] ; then
        echo "Check libIGCM_date ...........................................[ FAILED ]"
        echo "--Error--> libIGCM variable is not defined"
        IGCM_debug_Exit "IGCM_date_Check"
    fi

#---------------------
    whence -v gawk > /dev/null 2>&1
    if [ ! $? -eq 0 ] ; then
        echo "Check libIGCM_date ...........................................[ FAILED ]"
        echo "--Error--> gawk command is not defined"
        IGCM_debug_Exit "IGCM_date_Check"
    fi

#---------------------
    ${libIGCM}/libIGCM_date/IGCM_date_Test.ksh > IGCM_date_Test.ref.failed 2>&1
    
    if diff IGCM_date_Test.ref.failed ${libIGCM}/libIGCM_date/IGCM_date_Test${dY}.ref > /dev/null 2>&1 ; then 
        echo "Check libIGCM_date ...............................................[ OK ]"
        rm -f IGCM_date_Test.ref.failed
    else 
        echo "Check libIGCM_date ...........................................[ FAILED ]"
        echo "--Error--> Execution of ${libIGCM}/libIGCM_date/IGCM_date_Test.ksh"
        echo "           has produced the file IGCM_date_Test.ref.failed"
        echo "           Please analyse differences with the reference file by typing:"
        echo "           diff IGCM_date_Test.ref.failed ${libIGCM}/libIGCM_date/IGCM_date_Test${dY}.ref"
        echo "           Report errors to the author: Sebastien.Denvil@ipsl.jussieu.fr"
        IGCM_debug_Exit "IGCM_date_Check"
    fi

#---------------------
    IGCM_debug_PopStack "IGCM_date_Check"
}

#==================================================================