diff.c

Go to the documentation of this file.

/*
 * Copyright (C) 1995.  Bill Brown <brown@gis.uiuc.edu> & Michael Shapiro
 *
 * This program is free software under the GPL (>=v2)
 * Read the file GPL.TXT coming with GRASS for details.
 */
#include <stdlib.h>
#include <grass/datetime.h>
#include "math.h"

/*************************************************************/
/*
   This performs the formula:   result = a - b;

   both a and b must be absolute.
   result will be relative
   If a is "earlier" than b, then result should be set negative.

   b must be no more "precise" than a.
   (a copy of b is "extended" to the precision of a)

   datetime_copy (tb, b)
   datetime_reset_from_to (tb, b.from, a.to, a.fracsec))


   If result.to == SECOND, then result.fracsec is a.fracsec

   result will have the following from/to based on a.to:

   result
   a.to      from    to
   YEAR      YEAR    YEAR
   MONTH     YEAR    MONTH
   DAY       DAY     DAY
   HOUR      DAY     HOUR
   MINUTE    DAY     MINUTE
   SECOND    DAY     SECOND

   If either 'a' or 'b' has a timezone, both must have a timezone.
   The difference will account for the differences in the time zones.
 */

static int _datetime_ymd_to_ddays(const DateTime *, double *);
static int _datetime_compare(const DateTime *, const DateTime *);


/*!
 * \brief 
 *
 * 
 * This performs the formula:   result = a - b; 
 * <ul>
 <li> both a and b must be absolute.
 * </li>
 <li> result will be relative
 * </li>
 <li> If a is "earlier" than b, then result will be set negative.
 * </li>
 <li> b must be no more "precise" than a.
 * (a copy of b is "extended" to the precision of a)
 * </li>
 <li> If result.to == SECOND, then result.fracsec is a.fracsec
 * </li>
 <li> result will have the following from/to based
 * on a.to: result a.to      from    to YEAR      YEAR    YEAR MONTH     YEAR
 * MONTH DAY       DAY     DAY HOUR      DAY     HOUR MINUTE    DAY   
 * MINUTE SECOND    DAY     SECOND [LAYOUT ??? - see HTML]
 * </li>
 <li> If either 'a' or 'b' has a timezone, both must have a timezone. The
 * difference will account for the differences in the time zones.
 </li></ul>

 *
 *  \param a
 *  \param b
 *  \param result
 *  \return int
 */

int
datetime_difference(const DateTime * a, const DateTime * b, DateTime * result)
{
    DateTime tb, ta, *early, *late;
    int compare, tzmin;

    /* if not both absolute, return error */

    datetime_copy(&tb, b);
    datetime_change_from_to(&tb, DATETIME_YEAR, a->to, a->fracsec);

    datetime_copy(&ta, a);
    if (datetime_get_timezone(&ta, &tzmin) == 0 ||
        datetime_get_timezone(&tb, &tzmin) == 0) {
        if (datetime_get_timezone(&ta, &tzmin) == 0 &&
            datetime_get_timezone(&tb, &tzmin) == 0) {
            datetime_change_to_utc(&ta);
            datetime_change_to_utc(&tb);
        }
        else
            return datetime_error(-1,
                                  "only one opperand contains valid timezone");
    }

    /* initialize result */
    datetime_set_type(result, DATETIME_RELATIVE,
                      ta.to < DATETIME_DAY ? DATETIME_YEAR : DATETIME_DAY,
                      ta.to, ta.fracsec);
    compare = _datetime_compare(&ta, &tb);
    if (compare > 0) {
        early = &tb;
        late = &ta;
        result->positive = 1;
    }
    else if (compare < 0) {
        early = &ta;
        late = &tb;
        result->positive = 0;
    }
    else {                      /* equal */
        return (0);
    }

    /* now the work */
    if (datetime_in_interval_year_month(ta.to)) {
        int dm;

        if (ta.positive == tb.positive) {
            /* change if we use doubles! */
            result->year = abs(late->year - early->year);
        }
        else {
            result->year = late->year + early->year - 2;
        }
        dm = late->month - early->month;
        if (dm >= 0)
            result->month = dm;
        else {
            result->year -= 1;
            result->month = dm + 12;
        }
    }
    else {
        DateTime erel, lrel;
        double latedays, earlydays;

        datetime_set_increment_type(a, &erel);
        _datetime_ymd_to_ddays(early, &earlydays);
        /* copy day -> down */
        erel.day = earlydays;
        erel.hour = early->hour;
        erel.minute = early->minute;
        erel.second = early->second;

        datetime_set_increment_type(a, &lrel);
        _datetime_ymd_to_ddays(late, &latedays);
        /* copy day -> down */
        lrel.day = latedays;
        lrel.hour = late->hour;
        lrel.minute = late->minute;
        lrel.second = late->second;

        datetime_invert_sign(&erel);
        datetime_increment(&erel, &lrel);

        /* copy erel back to result */
        result->day = erel.day;
        result->hour = erel.hour;
        result->minute = erel.minute;
        result->second = erel.second;

        /* need carry? */
    }

    return (0);
}

/*************************************************************/
/* returns 1 if a is later than b, 
   -1 if a is earlier than a,
   0 otherwise 
 */
/* only looks at from-to fields defined by a */

static int _datetime_compare(const DateTime * a, const DateTime * b)
{
    int i;

    if (a->positive && !b->positive)
        return (1);
    else if (b->positive && !a->positive)
        return (-1);

    /* same signs */
    for (i = a->from; i <= a->to; i++) {
        switch (i) {

        case DATETIME_SECOND:
            if (a->second > b->second)
                return (1);
            else if (a->second < b->second)
                return (-1);
            break;

        case DATETIME_MINUTE:
            if (a->minute > b->minute)
                return (1);
            else if (a->minute < b->minute)
                return (-1);
            break;

        case DATETIME_HOUR:
            if (a->hour > b->hour)
                return (1);
            else if (a->hour < b->hour)
                return (-1);
            break;

        case DATETIME_DAY:
            if (a->day > b->day)
                return (1);
            else if (a->day < b->day)
                return (-1);
            break;

        case DATETIME_MONTH:
            if (a->month > b->month)
                return (1);
            else if (a->month < b->month)
                return (-1);
            break;

        case DATETIME_YEAR:     /* only place sign matters */
            if (a->positive) {
                if (a->year > b->year)
                    return (1);
                else if (a->year < b->year)
                    return (-1);
            }
            else {
                if (a->year < b->year)
                    return (1);
                else if (a->year > b->year)
                    return (-1);
            }
            break;
        }
    }
    return (0);


}

/*************************************************************/

static int _datetime_ymd_to_ddays(const DateTime * dtymd, double *days)
{                               /* note extra precision! */
    int yr, mo;


    *days = 0.0;

    if (dtymd->positive) {
        *days = dtymd->day - 1; /* start w/ days - 1 */
        for (mo = dtymd->month - 1; mo > 0; mo--) {     /* add earlier months */
            *days += datetime_days_in_month(dtymd->year, mo, dtymd->positive);
        }
        for (yr = dtymd->year - 1; yr > 0; yr--) {      /* add earlier years */
            *days += datetime_days_in_year(yr, dtymd->positive);
        }
    }
    else {
        for (yr = dtymd->year - 1; yr > 0; yr--) {      /* add later years */
            *days += datetime_days_in_year(yr, dtymd->positive);
        }
        for (mo = 12; mo >= dtymd->month; mo--) {       /*add current & later months */
            *days += datetime_days_in_month(dtymd->year, mo, dtymd->positive);
        }
        *days -= dtymd->day;    /* subtract current days */
    }

    return 0;
}

/*************************************************************/

/*************************************************************/