src/sct_operations.c

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2007 by Aleksander Morgado Juez                         *
 *   scitime@aleksander_morgado.mm.st                                      *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU Library General Public License as       *
 *   published by the Free Software Foundation; either version 2 of the    *
 *   License, or (at your option) any later version.                       *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU Library General Public     *
 *   License along with this program; if not, write to the                 *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#include "scitime.h"

SCT_RET sct_add_deltaDSF( \
    sct_time_ptr pDest, \
    const sct_time_ptr pSource, \
    const long nDays, \
    const long nSeconds, \
    const long nFemtosecs)
{
    sct_time deltaElement;

    //Create delta element...
    deltaElement.days = nDays;
    deltaElement.secs = nSeconds;
    deltaElement.fsecs = nFemtosecs;
    deltaElement.status = SCT_STATUS_DELTA;
    deltaElement.accuracy = SCT_ACCURACY_FEMTOSECS;

    //Return the sum
    return sct_add_delta(pDest,pSource, &deltaElement);
}


SCT_RET sct_add_delta( \
    sct_time_ptr pDest, \
    const sct_time_ptr pSource, \
    const sct_time_ptr pDelta)
{
    sct_time aux;       //To avoid changing source if it's the same as dest
    int64_t fsecs = 0;
    int64_t days = 0;
    int32_t secs = 0;

    //Check element
    if(pSource == NULL || pDelta == NULL || pDest == NULL)
    {
        //Ko, invalid pointer!
        #ifdef SCT_DEBUG
            if(pSource == NULL)
            {
                fprintf(stderr, \
                    "[scitime:%s] >> Unable to get source element to add!\n",
                    __FUNCTION__);
            }
            if(pDelta == NULL)
            {
                fprintf(stderr, \
                    "[scitime:%s] >> Unable to get delta element to add!\n",
                    __FUNCTION__);
            }
            if(pDest == NULL)
            {
                fprintf(stderr, \
                    "[scitime:%s] >> Unable to get output element!\n",
                    __FUNCTION__);
            }
        #endif
        return SCT_RET_INVALID_PTR;
    }
    if(pSource->status != SCT_STATUS_OK || pDelta->status != SCT_STATUS_DELTA)
    {
        #ifdef SCT_DEBUG
            if(pSource->status != SCT_STATUS_OK)
            {
                fprintf(stderr, "[scitime:%s] >> Source element to add not "
                    "initialised as epoch element!\n", __FUNCTION__);
            }
            if(pDelta->status != SCT_STATUS_DELTA)
            {
                fprintf(stderr, "[scitime:%s] >> Delta element to add not "
                    "initialised as delta element!\n", __FUNCTION__);
            }
        #endif
        return SCT_RET_NOT_INITIALISED;
    }

    //Copy source in the aux element
    sct_copy(&aux,pSource);

    //Sum femtosecs...
    fsecs = aux.fsecs + pDelta->fsecs;
    if(fsecs > SCT_FSECS_IN_SEC)
    {
        fsecs -= SCT_FSECS_IN_SEC;
        secs++;
    }

    //Sum seconds...
    secs += (aux.secs + pDelta->secs);
    if(secs > SCT_SECS_IN_DAY)
    {
        secs -= SCT_SECS_IN_DAY;
        days++;
    }

    //Sum days...
    days += (aux.days + pDelta->days);

    //Set output values...
    pDest->fsecs= fsecs;
    pDest->secs = secs;
    pDest->days = days;
    pDest->status = SCT_STATUS_OK;
    pDest->accuracy = pDelta->accuracy;

    //Check accuracy changes...
    if(aux.accuracy > pDelta->accuracy)
    {
        pDest->accuracy = aux.accuracy;
        #ifdef SCT_DEBUG
            fprintf(stderr, "[scitime:%s] >> Accuracy for epoch element (%d) is"
                " worse than the accuracy of the delta element (%d)! Output "
                "accuracy will be '%d'\n", __FUNCTION__, aux.accuracy,
                pDelta->accuracy, pDest->accuracy);
        #endif
    }
    else if(aux.accuracy < pDelta->accuracy)
    {
        #ifdef SCT_DEBUG
            fprintf(stderr, "[scitime:%s] >> Accuracy for delta element (%d) is"
                " worse than the accuracy of the epoch element (%d)! Output "
                "accuracy will be '%d'\n", __FUNCTION__, pDelta->accuracy,
               aux.accuracy, pDest->accuracy);
        #endif
    }

    //Ok, no problem
    return SCT_RET_OK;
}

SCT_RET sct_diff( \
    sct_time_ptr pDeltaDest, \
    const sct_time_ptr pEpoch1, \
    const sct_time_ptr pEpoch2)
{
    int64_t fsecs = 0;
    int64_t days = 0;
    int32_t secs = 0;

    //Check element
    if(pDeltaDest == NULL || pEpoch1 == NULL || pEpoch2 == NULL)
    {
        //Ko, invalid pointer!
        #ifdef SCT_DEBUG
            if(pEpoch1 == NULL)
            {
                fprintf(stderr, \
                    "[scitime:%s] >> Unable to get first epoch to substract!\n",
                    __FUNCTION__);
            }
            if(pEpoch2 == NULL)
            {
                fprintf(stderr, "[scitime:%s] >> Unable to get second epoch "
                    "to substract!\n", __FUNCTION__);
            }
            if(pDeltaDest == NULL)
            {
                fprintf(stderr, \
                    "[scitime:%s] >> Unable to get output element!\n",
                    __FUNCTION__);
            }
        #endif
        return SCT_RET_INVALID_PTR;
    }
    if(pEpoch1->status != SCT_STATUS_OK || pEpoch2->status != SCT_STATUS_OK)
    {
        #ifdef SCT_DEBUG
            if(pEpoch1->status != SCT_STATUS_OK)
            {
                fprintf(stderr, "[scitime:%s] >> First element not "
                    "initialised as epoch element!\n", __FUNCTION__);
            }
            if(pEpoch2->status != SCT_STATUS_OK)
            {
                fprintf(stderr, "[scitime:%s] >> Second element not "
                    "initialised as epoch element!\n", __FUNCTION__);
            }
        #endif
        return SCT_RET_NOT_INITIALISED;
    }

    //Substract femtosecs...
    fsecs = pEpoch1->fsecs - pEpoch2->fsecs;
    if(fsecs < -SCT_FSECS_IN_SEC)
    {
        fsecs += SCT_FSECS_IN_SEC;
        secs--;
    }

    //Substract secs...
    secs += (pEpoch1->secs - pEpoch2->secs);
    if(secs < -SCT_SECS_IN_DAY)
    {
        secs += SCT_SECS_IN_DAY;
        days--;
    }

    //Substract days...
    days += (pEpoch1->days - pEpoch2->days);

    //Set output values...
    pDeltaDest->fsecs = fsecs;
    pDeltaDest->secs = secs;
    pDeltaDest->days = days;
    pDeltaDest->status = SCT_STATUS_DELTA;
    pDeltaDest->accuracy = (pEpoch1->accuracy > pEpoch2->accuracy) ? \
        pEpoch1->accuracy : pEpoch2->accuracy;
    //Check accuracy changes...
    #ifdef SCT_DEBUG
        if(pEpoch1->accuracy > pEpoch2->accuracy)
        {
            fprintf(stderr, "[scitime:%s] >> Accuracy for first epoch element"
                " (%d) is worse than the accuracy of the second epoch element"
                " (%d)! Output accuracy will be '%d'\n", __FUNCTION__,
                pEpoch1->accuracy, pEpoch2->accuracy, pDeltaDest->accuracy);
        }
        else if(pEpoch1->accuracy < pEpoch2->accuracy)
        {
            fprintf(stderr, "[scitime:%s] >> Accuracy for second epoch element"
                " (%d) is worse than the accuracy of the first epoch element"
                " (%d)! Output accuracy will be '%d'\n", __FUNCTION__,
                pEpoch2->accuracy, pEpoch1->accuracy, pDeltaDest->accuracy);
        }
    #endif

    //Ok, no problem
    return SCT_RET_OK;
}

int sct_compare ( \
    const sct_time_ptr pEpoch1, \
    const sct_time_ptr pEpoch2, \
    const double epsilon)
{
    sct_time delta;
    double secs;
    sct_diff(&delta, pEpoch1, pEpoch2);
    sct_get_delta_secs(&delta, &secs);
    if(secs > epsilon)
    {
        return 1;
    }
    if(secs < (0-epsilon))
    {
        return -1;
    }
    return 0;
}

---