core/schedule.c

Go to the documentation of this file.

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <float.h>
#include <ctype.h>

#include "platform.h"
#include "object.h"
#include "output.h"
#include "schedule.h"
#include "exception.h"

#ifndef QNAN
#define QNAN sqrt(-1)
#endif

static SCHEDULE *schedule_list = NULL;
static SCHEDULEXFORM *schedule_xformlist=NULL;

SCHEDULEXFORM *scheduletransform_getnext(SCHEDULEXFORM *xform)
{
    return xform?xform->next:schedule_xformlist;
}

int schedule_add_xform(XFORMSOURCE stype,   /* specifies the type of source */
                       double *source,      /* pointer to the source value */
                       double *target,      /* pointer to the target value */
                       double scale,        /* transform scalar */
                       double bias,         /* transform offset */
                       OBJECT *obj,         /* object containing target value */
                       PROPERTY *prop)      /* property associated with target value */
{
    SCHEDULEXFORM *xform = (SCHEDULEXFORM*)malloc(sizeof(SCHEDULEXFORM));
    if (xform==NULL)
        return 0;
    xform->source_type = stype;
    xform->source = source;
    xform->source_addr = source; /* this assumes the double is the first member of the structure */
    xform->target_obj = obj;
    xform->target_prop = prop;
    xform->target = target;
    xform->scale = scale;
    xform->bias = bias;
    xform->next = schedule_xformlist;
    schedule_xformlist = xform;
    return 1;
}

SCHEDULE *schedule_getnext(SCHEDULE *sch) 
{
    return sch==NULL ? schedule_list : sch->next;
}

SCHEDULE *schedule_find_byname(char *name) 
{
    SCHEDULE *sch;
    for (sch=schedule_list; sch!=NULL; sch=sch->next)
    {
        if (strcmp(sch->name,name)==0)
            return sch;
    }
    return NULL;
}

/* performs a schedule pattern match 
   patterns:
     *
     #
     #-#
     ...,...
     
 */
int schedule_matcher(char *pattern, unsigned char *table, int max, int base)
{
    int go=0;
    int start=0;
    int stop=-1;
    int range=0;
    char *p;
    memset(table,0,max);
    for (p=pattern; ; p++)
    {
        switch (*p) {
        case '\0':
            go = 1;
            break;
        case '*':
            /* full range and go fill */
            start=base; stop=max; go=1;
            break;
        case ',':
            /* go fill */
            go = 1;
            break;
        case '-':
            /* partial range */
            range = 1; 
            stop = 0;
            break;
        case '0':
        case '1':
        case '2':
        case '3':
        case '4':
        case '5':
        case '6':
        case '7':
        case '8':
        case '9':
            if (range)
                stop = stop*10 + (*p-'0');
            else
                stop = start = start*10 + (*p-'0');
            break;
        default:
            return 0;
            break;
        }
        if (go && stop>=0)
        {   int i;

            /* check under limit */
            if (start<base)
            {
                output_warning("schedule_matcher(char *pattern='%s',...) start before min of %d", pattern,base);
                start = base;
            }

            /* check over limit */
            if (stop>max)
            {
                output_warning("schedule_matcher(char *pattern='%s',...) end exceed max of %d", pattern,max);
                stop = max;
            }

            /* go fill */
            if (start>stop) /* wraparound */
            {
                for (i=start; i<=max; i++)
                    table[i-base] = 1;
                for (i=base; i<=stop; i++)
                    table[i-base] = 1;
            }
            else
            {
                for (i=start; i<=stop; i++)
                    table[i-base] = 1;
            }

            /* reset */
            start = range = go = 0;
            stop = -1;
        }
        if (*p=='\0')
            break;
    }

    return 1;
}

int find_value_index (SCHEDULE *sch, 
                      unsigned char block, 
                      double value) 
{
    int ndx;
    for (ndx=0; ndx<(int)(sch->count[block]); ndx++)
    {
        if ((float)(sch->data[block*MAXVALUES+ndx]) == (float)value)
            return ndx;
    }
    return -1;
}

/* compiles a single schedule block and report errors
   returns 1 on success, 0 on failure 
 */
int schedule_compile_block(SCHEDULE *sch, char *blockname, char *blockdef)
{
    char *token = NULL;
    unsigned int minute=0;

    /* check block count */
    if (sch->block>=MAXBLOCKS)
    {
        output_error("schedule_compile(SCHEDULE *sch='{name=%s, ...}') maximum number of blocks reached", sch->name);
        /* TROUBLESHOOT
           The schedule definition has too many blocks to compile.  Consolidate your schedule and try again.
         */
        return 0;
    }

    /* first index is always default value 0 */
    sch->count[sch->block]=1;
    while ( (token=strtok(token==NULL?blockdef:NULL,";\r\n"))!=NULL )
    {
        struct {
            char *name;
            int base;
            int max;
            char pattern[256];
            char table[60];
        } matcher[] = {
            {"minute",0,59},
            {"hour",0,23},
            {"day",1,31},
            {"month",1,12},
            {"weekday",0,8},
        }, *match;
        unsigned int calendar;
        double value=1.0; /* default value is 1.0 */
        int ndx;

        /* remove leading whitespace */
        while (isspace(*token)) token++;
        if (strcmp(token,"")==0)
            continue;
        if (sscanf(token,"%s%*[ \t]%s%*[ \t]%s%*[ \t]%s%*[ \t]%s%*[ \t]%lf",matcher[0].pattern,matcher[1].pattern,matcher[2].pattern,matcher[3].pattern,matcher[4].pattern,&value)<5) /* value can be missing -> defaults to 1.0 */
        {
            output_error("schedule_compile(SCHEDULE *sch='{name=%s, ...}') ignored an invalid definition '%s'", sch->name, token);
            /* TROUBLESHOOT
               The schedule definition is not valid and has been ignored.  Check the syntax of your schedule and try again.
             */
            continue;
        }
        else
        {
            if ((ndx=find_value_index(sch,sch->block,value))==-1)
            {   
                ndx = sch->count[sch->block]++;
                // bound checking
                if(ndx > MAXVALUES-1)
                {
                    output_error("schedule_compile(SCHEDULE *sch='{name=%s, ...}') maximum number of values reached in block %i", sch->name, sch->block);
                    return 0;
                }
                sch->data[sch->block*MAXVALUES+ndx] = value;
            }
            sch->sum[sch->block] += value;
            sch->abs[sch->block] += (value<0?-value:value); // check to see if the value already exists in the value array, if so, don't ++index and use existing indexed value
        }

        /* compile matching tables */
        for (match=matcher; match<matcher+sizeof(matcher)/sizeof(matcher[0]); match++)
        {
            /* get match tables */
            if (!schedule_matcher(match->pattern,match->table,match->max,match->base))
            {
                output_error("schedule_compile(SCHEDULE *sch={name='%s', ...}) %s pattern syntax error in item '%s'", sch->name, match->name, token);
                /* TROUBLESHOOT
                    The schedule definition is not valid and has been ignored.  Check the syntax of your schedule and try again.
                */
                return 0;
            }
        }

        /* load schedule based on weekday of Jan 1 */
        for (calendar=0; calendar<14; calendar++) // don't do holidays (requires a special case that's not supported yet)
        {
            unsigned int weekday = calendar%7;
            unsigned int is_leapyear = (calendar>=7?1:0);
            unsigned int calendar = weekday*2+is_leapyear;
            unsigned int month;
            unsigned int days[] = {31,(is_leapyear?29:28),31,30,31,30,31,31,30,31,30,31};
            unsigned int n = sch->block*MAXVALUES + ndx;
            minute = 0;
            for (month=0; month<12; month++)
            {
                unsigned int day;
                if (!matcher[3].table[month])
                {
                    minute+=60*24*days[month];
                    continue;
                }
                for (day=0; day<days[month]; weekday++,day++)
                {
                    unsigned int hour;
                    weekday%=7; /* wrap day of week */
                    if (!matcher[4].table[weekday] || !matcher[2].table[day])
                    {
                        minute+=60*24;
                        continue;
                    }
                    for (hour=0; hour<24; hour++)
                    {
                        unsigned int stop = minute+60;
                        if (!matcher[1].table[hour])
                        {
                            minute = stop;
                            continue;
                        }
                        while (minute<stop)
                        {
                            if (matcher[0].table[minute%60])
                            {
                                if (sch->index[calendar][minute]>0)
                                {
                                    char *dayofweek[] = {"Sun","Mon","Tue","Wed","Thu","Fri","Sat","Sun","Hol"};
                                    output_error("schedule_compile(SCHEDULE *sch={name='%s', ...}) '%s' in block '%s' has a conflict with value %g on %s %d/%d %02d:%02d", sch->name, token, blockname, sch->data[sch->index[calendar][minute]], dayofweek[weekday], month+1, day+1, hour, minute%60);
                                    /* TROUBLESHOOT
                                       The schedule definition is not valid and has been ignored.  Check the syntax of your schedule and try again.
                                     */
                                    return 0;
                                }
                                else
                                {
                                    /* associate this time with the current value */
                                    sch->index[calendar][minute] = n;
                                    sch->weight[n]++;
                                    sch->minutes[sch->block]++;

                                }
                            }
                            minute++;
                        }
                    }
                }
            }
        }
    }
    strcpy(sch->blockname[sch->block],blockname);
    return 1;
}

/* compiles a multi-block schedule and report errors
   returns 1 on success, 0 on failure 
 */
int schedule_compile(SCHEDULE *sch)
{
    char *p = sch->definition, *q = NULL;
    char blockdef[65536];
    char blockname[64];
    enum {INIT, NAME, OPEN, BLOCK, CLOSE} state = INIT;
    int comment=0;
    
    /* check to see no blocks are defined */
    if (strchr(p,'{')==NULL && strchr(p,'}')==NULL)
    {
        /* this is single block unnamed schedule */
        /* remove leading whitespace */
        while (isspace(*p)) p++;
        strcpy(blockdef,p);
        if (schedule_compile_block(sch,"*",blockdef))
        {
            sch->block++;
            return 1;
        }
        else
            return 0;
    }

    /* isolate each block */
    while (*p!='\0')
    {
        /* handle comments */
        if (*p=='#') 
        {
            comment=1;
            p++;
            continue;
        }
        else if (comment)
        {
            if (*p=='\n')
                comment=0;
            p++;
            continue;
        }

        switch (state) {
        case INIT:
        case CLOSE:
            if (!isspace(*p) && !iscntrl(*p)) 
            {
                if (sch->block>=MAXBLOCKS)
                {
                    output_error("maximum number of allowed schedule blocks exceeded");
                    /* TROUBLESHOOT
                        Up to 4 schedule blocks are allowed.  Define your schedule so it only uses four blocks and try again.
                     */
                    return 0;
                }
                state = NAME;
                q = blockname;
                /* do not accept character yet */
            }
            else /* space/control */
                p++;
            break;
        case NAME:
            if (isspace(*p) || iscntrl(*p)) 
            {
                state = OPEN;
                p++;
            }
            else if (*p=='{' || *p==';')
            {
                state = OPEN;
            }
            else /* valid text */
            {
                if (q<blockname+sizeof(blockname)-1)
                {
                    *q++ = *p++;
                    *q = '\0';
                }
                else
                {
                    output_error("schedule name is too long");
                    /* TROUBLESHOOT
                        The name given the schedule is too long to be used.  Use a name that is less than 64 characters and try again.
                     */
                    return 0;
                }
            }
            break;
        case OPEN:
            if (*p==';') /* option */
            {
                if (strcmp(blockname,"weighted")==0)
                    sch->flags |= SN_WEIGHTED;
                else if (strcmp(blockname,"absolute")==0)
                    sch->flags |= SN_ABSOLUTE;
                else if (strcmp(blockname,"normal")==0)
                    sch->flags |= SN_NORMAL;
                else if (strcmp(blockname,"positive")==0)
                    sch->flags |= SN_POSITIVE;
                else if (strcmp(blockname,"nonzero")==0)
                    sch->flags |= SN_NONZERO;
                else if (strcmp(blockname,"boolean")==0)
                    sch->flags |= SN_BOOLEAN;
                else
                    output_error("schedule %s: block option '%s' is not recognized", sch->name, blockname);
                state = CLOSE;
                p++;
            }
            else if (*p=='{') /* open block */
            {
                state = BLOCK;
                q = blockdef;
                p++;
            }
            else if (!isspace(*p) && !iscntrl(*p)) /* non-white/control */
            {
                output_error("schedule %s: unexpected text before block start", sch->name);
                /* TROUBLESHOOT
                    The schedule syntax is not valid.  Remove the unexpected or invalid text before the block and try again.
                 */
                return 0;
            }
            else /* space/control */
                p++;
            break;
        case BLOCK:
            if (*p=='}')
            {   /* end block */
                state = CLOSE;
                q = NULL;
                p++;
                if (schedule_compile_block(sch,blockname,blockdef))
                    sch->block++;
                else
                    return 0;
            }
            else 
            {
                if (q<blockdef+sizeof(blockdef)-1)
                {
                    *q++ = *p++;
                    *q = '\0';
                }
                else
                {
                    output_error("schedule name is too long");
                    /* TROUBLESHOOT
                        The definition given the schedule is too long to be used.  Use a definition that is less than 1024 characters and try again.
                     */
                    return 0;
                }
            }
            break;
        default:
            break;
        }
    }
    return 1;
}

SCHEDULE *schedule_create(char *name,       
                          char *definition) 
{
    /* find the schedule is already defined (by name) */
    SCHEDULE *sch = schedule_find_byname(name);
    if (sch!=NULL) 
    {
        if (definition!=NULL && strcmp(sch->definition,definition)!=0)
        {
            output_error("schedule_create(char *name='%s', char *definition='%s') definition does not match previous definition of schedule '%s')", name, definition, name);
            /* TROUBLESHOOT
                There is more than 1 schedule with a given name, but they have different definitions.  Under certain circumstances, this can 
                lead to unpredictable simulation results and should be remedied by using a distinct name for each distinct schedule.
             */
        }
        return sch;
    }

    /* create without a definition is simply a search */
    else if (definition==NULL)
    {
        return NULL;
    }

    /* create a new schedule */
    sch = schedule_new();
    if (sch==NULL)
    {
        output_error("schedule_create(char *name='%s', char *definition='%s') memory allocation failed)", name, definition);
        /* TROUBLESHOOT
            The schedule module could not allocate enough memory to create a schedule item.  Try freeing system memory and try again.
         */
        return NULL;
    }
    output_debug("schedule '%s' uses %.1f MB of memory", name, sizeof(SCHEDULE)/1000000.0);
    if (strlen(name)>=sizeof(sch->name))
    {
        output_error("schedule_create(char *name='%s', char *definition='%s') name too long)", name, definition);
        /* TROUBLESHOOT
            The name given the schedule is too long to be used.  Use a name that is less than 64 characters and try again.
         */
        free(sch);
        return NULL;
    }
    strcpy(sch->name,name);
    if (strlen(definition)>=sizeof(sch->definition))
    {
        output_error("schedule_create(char *name='%s', char *definition='%s') definition too long)", name, definition);
        /* TROUBLESHOOT
            The definition given the schedule is too long to be used.  Use a definition that is less than 1024 characters and try again.
         */
        free(sch);
        return NULL;
    }
    strcpy(sch->definition,definition);

    /* compile the schedule */
    if (schedule_compile(sch))
    {
        /* construct the dtnext array */
        unsigned char calendar;
        int invariant = 1;
        for (calendar=0; calendar<14; calendar++)
        {
            /* number of minutes that are indexed */
            int t = sizeof(sch->dtnext[calendar])/sizeof(sch->dtnext[calendar][0])-1;

            /* assume that loopback results in a value change in 1 minute */
            sch->dtnext[calendar][t] = 1; 

            /* scan backwards through time */
            for (t--; t>=0; t--)
            {
                /* get this and the next index to values */
                int index0 = sch->index[calendar][t];
                int index1 = sch->index[calendar][t+1];

                /* if the values are the same */
                if (sch->data[index0]==sch->data[index1])
                {   
                    /* if we haven't reached the maximum delta-t (for unsigned char dtnext) */
                    if (sch->dtnext[calendar][t]<255)

                        /* add 1 minute to next values time */
                        sch->dtnext[calendar][t] = sch->dtnext[calendar][t+1] + 1;
                    else

                        /* start the time over at 1 minute (to next value) */
                        sch->dtnext[calendar][t] = 1;
                }
                else
                {
                    /* start the time over at 1 minute (to next value) */
                    sch->dtnext[calendar][t] = 1;
                    invariant = 0;
                }
            }
        }

        /* special case for invariant schedule */
        if (invariant)
            memset(sch->dtnext,0,sizeof(sch->dtnext)); /* zero means never */

        /* normalize */
        if (sch->flags!=0)
            schedule_normalize(sch,sch->flags);

        /* validate */
        if ((sch->flags&(SN_POSITIVE|SN_NONZERO|SN_BOOLEAN)) != 0 && ! schedule_validate(sch,sch->flags))
            return NULL;

        /* attach to schedule list */
        schedule_add(sch);
        return sch;
    }
    else
    {
        /* error message should be given by schedule_compile */
        free(sch);
        return NULL;
    }
}

SCHEDULE *schedule_new(void)
{
    /* create the schedule */
    SCHEDULE *sch = (SCHEDULE*)malloc(sizeof(SCHEDULE));
    if (sch==NULL) return NULL;

    /* initialize */
    memset(sch,0,sizeof(SCHEDULE));
    sch->next_t = TS_NEVER;
    return sch;
}
void schedule_add(SCHEDULE *sch)
{
    sch->next = schedule_list;
    schedule_list = sch;
}

int schedule_validate(SCHEDULE *sch, int flags)
{
    unsigned int b,i;
    int failed=0;
    for (b=0; b<MAXBLOCKS; b++) {
        for (i=1; i<=sch->count[b]; i++)
        {
            double value = sch->data[b*MAXVALUES+i];
            int weight = sch->weight[b*MAXVALUES+i];
            int unit =  (weight>0 && value==1.0);
            int zero = (weight>0 && value==0.0);
            int positive = (weight>0 && value>0.0);
            int negative = (weight>0 && value<0.0);
            if ((flags&SN_BOOLEAN) && !(unit || zero))
            {
                output_error("schedule %s fails 'boolean' validation in block %s at schedule index %d", sch->name, sch->blockname[b], i);
                failed = 1;
            }
            else if ((flags&SN_POSITIVE) && negative)
            {
                output_error("schedule %s fails 'positive' validation in block %s at schedule index %d", sch->name, sch->blockname[b], i);
                failed = 1;
            }
            else if ((flags&SN_NONZERO) && zero)
            {
                output_error("schedule %s fails 'nonzero' validation in block %s at schedule index %d", sch->name, sch->blockname[b], i);
                failed = 1;
            }
        }
    }
    return !failed;
}

int schedule_normalize(SCHEDULE *sch,   
                       int flags)       
{
    unsigned int b,i;
    int count=0;

    /* check if already normalized */
    if (sch->flags&flags)
        return -1;

    /* normalized */
    for (b=0; b<MAXBLOCKS; b++)
    {
        /* ignore empty blocks */
        if (sch->count[b]==0)
            continue;

        /* weighted normalization */
        if (flags&SN_WEIGHTED)
        {   
            double scale[MAXVALUES];
            unsigned int i;
            int nonzero = 0;
            memset(scale,0,sizeof(scale));
            for (i=1; i<=sch->count[b]; i++)
            {
                if (sch->weight[i]!=0)
                {
                    nonzero = 1;
                    scale[i] += sch->data[b*MAXVALUES+i] * sch->weight[i] / sch->minutes[b];
                }
            }
            if (nonzero)
            {
                for (i=1; i<=sch->count[b]; i++)
                    sch->data[b*MAXVALUES+i]*=scale[i];
            }
        }

        /* unweighted normalization */
        else
        {
            double scale = (flags&SN_ABSOLUTE?sch->abs[b]:sch->sum[b]);

            /* if the coefficient is non-zero */
            if (scale!=0)
            {
                /* normalize the values */
                count++;
                for (i=1; i<=sch->count[b]; i++)
                    sch->data[b*MAXVALUES+i]/=scale;
            }
        }
    }

    /* mark as normalized */
    sch->flags |= flags;

    return count;
}

SCHEDULEINDEX schedule_index(SCHEDULE *sch, TIMESTAMP ts)
{
    SCHEDULEINDEX ref = 0;
    DATETIME dt;
    
    /* determine the local time */
    if (!local_datetime(ts,&dt))
    {
        throw_exception("schedule_read(SCHEDULE *schedule={name='%s',...}, TIMESTAMP ts=%"FMT_INT64"d) unable to determine local time", sch->name, ts);
        /* TROUBLESHOOT
            The schedule could not be read because the local time could not be determined.  
            Fix the problem causing the local time system failure and try again.
         */
    }

    /* determine which calendar is used based on the weekday of Jan 1 and LY status */
    SET_CALENDAR(ref, ((dt.weekday-dt.yearday+53*7)%7)*2 + ISLEAPYEAR(dt.year));

    /* compute the minute of year */
    SET_MINUTE(ref, (dt.yearday*24 + dt.hour)*60 + dt.minute);

    /* got it */
    return ref;
}

double schedule_value(SCHEDULE *sch,        
                      SCHEDULEINDEX index)  
{
    long int cal = GET_CALENDAR(index);
    long int min = GET_MINUTE(index);
    return sch->data[sch->index[GET_CALENDAR(index)][GET_MINUTE(index)]];
}

long schedule_dtnext(SCHEDULE *sch,         
                     SCHEDULEINDEX index)   
{
    return sch->dtnext[GET_CALENDAR(index)][GET_MINUTE(index)];
}

long schedule_duration(SCHEDULE *sch,           
                       SCHEDULEINDEX index) 
{
    int block = (sch->index[GET_CALENDAR(index)][GET_MINUTE(index)]>>6)&MAXBLOCKS; // these change if MAXVALUES or MAXBLOCKS changes
    return sch->minutes[block];
}

double schedule_weight(SCHEDULE *sch,           
                       SCHEDULEINDEX index) 
{
    return sch->weight[sch->index[GET_CALENDAR(index)][GET_MINUTE(index)]];
}

TIMESTAMP schedule_sync(SCHEDULE *sch, 
                        TIMESTAMP t)    
{
    static TIMESTAMP last_t = 0;
    static SCHEDULEINDEX index = {0};
    double value;
    long dtnext;
    double duration;
    
    /* get the current schedule status */
    if (t!=last_t) index = schedule_index(sch,t);
    value = schedule_value(sch,index);
    dtnext = schedule_dtnext(sch,index)*60;
    duration = (double)schedule_duration(sch,index);

    /* if the schedule is changing value */
    if (value!=sch->value || sch->duration!=duration)
    {
        /* record the next value and its duration */
        sch->value = value;
        sch->duration = duration / 60;
        sch->fraction = schedule_weight(sch,index) / duration;
    }

    /* compute the time of the next schedule change */
    sch->next_t = (dtnext==0 ? TS_NEVER : t + dtnext -  t % 60);
    return sch->next_t;
}

TIMESTAMP schedule_syncall(TIMESTAMP t1) 
{
    SCHEDULE *sch;
    TIMESTAMP t2 = TS_NEVER;
    for (sch=schedule_list; sch!=NULL; sch=sch->next)
    {
        TIMESTAMP t3 = schedule_sync(sch,t1);
        if (t3<t2) t2 = t3;
    }

    return t2;
}

TIMESTAMP scheduletransform_syncall(TIMESTAMP t1, XFORMSOURCE restrict)
{
    SCHEDULEXFORM *xform;
    /* process the schedule transformations */
    for (xform=schedule_xformlist; xform!=NULL; xform=xform->next)
    {   
        if (xform->source_type&restrict)
            *(xform->target) = *(xform->source) * xform->scale + xform->bias;
    }
    return TS_NEVER;
}

int schedule_test(void)
{
    int failed = 0;
    int ok = 0;
    int errorcount = 0;
    char ts[64];

    /* tests */
    struct s_test {
        char *name, *def;
        char *t1, *t2;
        int normalize;
        double value;
    } *p, test[] = {
        /* schedule name    schedule definition                         sync time               next time expected      normalize   value expected */
        {"empty",           "",                                         "2000/01/01 00:00:00",  "NEVER",                0,           0.0},
        {"halfday-binary",  "* 12-23 * * *",                            "2001/02/03 01:30:00",  "2001/02/03 12:00:00",  0,           0.0},
        {"halfday-binary",  NULL,                                       "2002/03/05 13:45:00",  "2002/03/06 00:00:00",  0,           1.0},
        {"halfday-bimodal", "* 0-11 * * * 0.25; * 12-23 * * * 0.75;",   "2003/04/07 01:15:00",  "2003/04/07 12:00:00",  0,           0.25},
        {"halfday-bimodal", "* 0-11 * * * 0.25; * 12-23 * * * 0.75;",   "2004/05/09 00:00:00",  "2004/05/09 12:00:00",  0,           0.25},
        {"halfday-bimodal", NULL,                                       "2005/06/11 13:20:00",  "2005/06/12 00:00:00",  0,           0.75},
        {"halfday-bimodal", NULL,                                       "2006/07/13 12:00:00",  "2006/07/14 00:00:00",  0,           0.75},
        {"halfday-bimodal", NULL,                                       "2007/08/15 00:00:00",  "2007/08/15 12:00:00",  0,           0.25},
        {"quarterday-normal", "* 0-5 * * *; * 12-17 * * *;",            "2008/09/17 00:00:00",  "2008/09/17 06:00:00",  SN_WEIGHTED, 0.5},
        {"quarterday-normal", NULL,                                     "2009/10/19 06:00:00",  "2009/10/19 12:00:00",  SN_WEIGHTED, 0.0},
        {"quarterday-normal", NULL,                                     "2010/11/21 12:00:00",  "2010/11/21 18:00:00",  SN_WEIGHTED, 0.5},
        {"quarterday-normal", NULL,                                     "2011/12/23 18:00:00",  "2011/12/24 00:00:00",  SN_WEIGHTED, 0.0},
    };

    output_test("\nBEGIN: schedule tests");
    for (p=test;p<test+sizeof(test)/sizeof(test[0]);p++)
    {
        TIMESTAMP t1 = convert_to_timestamp(p->t1);
        int errors=0;
        SCHEDULE *s = schedule_create(p->name, p->def);
        output_test("Schedule %s { %s } sync to %s...", p->name, p->def?p->def:(s?s->definition:"???"), convert_from_timestamp(t1,ts,sizeof(ts))?ts:"???");
        if (s==NULL)
        {
            output_test(" ! schedule %s { %s } create failed", p->name, p->def);
            errors++;
        }
        else
        {
            TIMESTAMP t2;
            if (p->normalize) 
                schedule_normalize(s,p->normalize);
            t2 = s?schedule_sync(s,t1):TS_NEVER;
            if (s->value!=p->value)
            {
                output_test(" ! expected value %lg but found %lg",  p->value, s->value);
                errors++;
            }
            if (t2!=convert_to_timestamp(p->t2))
            {
                output_test(" ! expected next time %s but found %s", p->t2, convert_from_timestamp(t2,ts,sizeof(ts))?ts:"???");
                errors++;
            }
        }
        if (errors==0)
        {
            output_test("   test passed");
            ok++;
        }
        else
            failed++;
        errorcount+=errors;
    }

    /* report results */
    if (failed)
    {
        output_error("scheduletest: %d schedule tests failed--see test.txt for more information",failed);
        output_test("!!! %d schedule tests failed, %d errors found",failed,errorcount);
    }
    else
    {
        output_verbose("%d schedule tests completed with no errors--see test.txt for details",ok);
        output_test("scheduletest: %d schedule tests completed, %d errors found",ok,errorcount);
    }
    output_test("END: schedule tests");
    return failed;
}

void schedule_dump(SCHEDULE *sch, char *file)
{
    FILE *fp = fopen(file,"w");
    int calendar;


    fprintf(fp,"schedule %s { %s }\n", sch->name, sch->definition);
    fprintf(fp,"sizeof(SCHEDULE) = %.3f MB\n", (double)sizeof(SCHEDULE)/1024/1024);
    for (calendar=0; calendar<14; calendar++)
    {
        int year=0, month, y;
        int daysinmonth[] = {31,((calendar&1)?29:28),31,30,31,30,31,31,30,31,30,31};
        char *monthname[] = {"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"};
        fprintf(fp,"\nYears:");
        for (y=1970; y<2039; y++)
        {
            DATETIME dt = {y,0,1,0,0,0};
            TIMESTAMP ts = mkdatetime(&dt);
            SCHEDULEINDEX ndx = schedule_index(sch,ts);
            if (GET_CALENDAR(ndx)==calendar)
            {
                fprintf(fp," %d",y);
                if (year==0) year=y;
            }
        }
        fprintf(fp," (calendar %d)\n",calendar);

        for (month=0; month<12; month++)
        {
            int day, hour;
            fprintf(fp,"     %s  ", monthname[month]);
            for (hour=0; hour<24; hour++)
            {
                fprintf(fp," %2d:00", hour);
            }
            fprintf(fp,"\n");
            for (day=0; day<daysinmonth[month]; day++)
            {
                int hour;
                char wd[] = "SMTWTFSH";
                DATETIME dt = {year,month,day,0,0,0,0,0,""};
                TIMESTAMP ts = mkdatetime(&dt);
                local_datetime(ts,&dt);
                fprintf(fp,"      %c %2d",wd[dt.weekday],day+1);
                for (hour=0; hour<24; hour++)
                {
                    int minute=0;
                    DATETIME dt = {year,month,day,hour,0,0};
                    TIMESTAMP ts = mkdatetime(&dt);
                    SCHEDULEINDEX ndx = schedule_index(sch,ts);
                    fprintf(fp,"%5g%c",schedule_value(sch,ndx),schedule_dtnext(sch,ndx)<60?'*':' ');
                }
                fprintf(fp,"\n");
            }
        }
    }

    fclose(fp);
}

---

GridLAB-D^TM Version 2.0

An open-source project initiated by the US Department of Energy