/Users/asorokin/Documents/workspaceC/Decima/ts/tsoperators.c

Go to the documentation of this file.

/*-------------------------------------------------------------------------
 *
 * tsoperators.h
 *
 *
 * Author: Anatoly Sorokin <asorokin@inf.ed.ac.uk>
 *
 *   $Id: tsoperators.c 28 2009-07-17 17:18:31Z lptolik $
 *
 *-------------------------------------------------------------------------
 *
 * Copyright 2009 Anatoly Sorokin, School of Informatics, The University of Edinburgh
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *          http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *-------------------------------------------------------------------------
 */
#include "postgres.h"

#include <float.h>
#include <math.h>             /* for HUGE_VAL */

#include "access/gist.h"
#include "access/skey.h"
#include "utils/builtins.h"
#include "lib/stringinfo.h"
#include "utils/array.h"

#include "tsdata.h"

#define FALSE 0
#define TRUE 1

/*
Datum ts_uoverlap(PG_FUNCTION_ARGS);
Datum ts_loverlap(PG_FUNCTION_ARGS);
*/



bool ts_uoverlap(TS   *a,TS   *b){
   int i;
   int   length = (a->length >= b->length) ? b->length : a->length;
//   elog(NOTICE, "min length: '%x'", length);

   for(i=0;i<length;i++){
      if(b->data[i].lower > a->data[i].lower || a->data[i].lower > b->data[i].upper) return false;
   }
   return true;
}

bool ts_loverlap(TS   *a,TS   *b){
   int i;
   int   length = (a->length >= b->length) ? b->length : a->length;
   for(i=0;i<length;i++){
      if(b->data[i].upper < a->data[i].upper || a->data[i].upper < b->data[i].lower) return false;
   }
   return true;

}

bool ts_contained(TS   *a,TS   *b){
   return (ts_uoverlap(a,b) && ts_loverlap(a,b));
}


bool ts_contains(TS   *a,TS   *b){
   return (ts_contained(b,a));
}

bool ts_intersect(TS   *a,TS   *b){
   return !(ts_greater(a,b) || ts_less(a,b));
}


bool ts_greater(TS   *a,TS   *b){
   int i;
   int   length = (a->length >= b->length) ? b->length : a->length;
   for(i=0;i<length;i++){
      if(b->data[i].upper >= a->data[i].lower) return false;
   }
   return true;

}


bool ts_less(TS   *a,TS   *b){
   int i;
   int   length = (a->length >= b->length) ? b->length : a->length;
   for(i=0;i<length;i++){
      if(b->data[i].lower <= a->data[i].upper) return false;
   }
   return true;

}

bool ts_wcontained(TS   *a,TS   *b){
   int i,size,sax_len;
   SAX *as, *bs;
   bool result;
   sax_len=ceil((double)a->length/WEAK_CHAR_LENGTH);
   elog(NOTICE, "a_SAX length: '%x'", sax_len);

   as= (SAX *) palloc0(size);
   SET_VARSIZE(as, size);
   i_ts_sax(a, sax_len,as);

   sax_len=ceil((double)b->length/WEAK_CHAR_LENGTH);
   elog(NOTICE, "a_SAX length: '%x'", sax_len);
   bs= (SAX *) palloc0(size);
   SET_VARSIZE(bs, size);
   i_ts_sax(b, sax_len,bs);
   result=sax_contained(as,bs);
   pfree(as);
   pfree(bs);
   return result;

}

bool ts_wcontains(TS   *a,TS   *b){
   return (ts_wcontained(b,a));
}

---