| |
| /* |
| * File Name: keyUnion.c |
| * Purpose: Calculates the index key union of either a pair of index |
| * keys or a list of index entries. The routine which |
| * calculates the union of a list of index entries uses the |
| * routine which calculates the union of a pair of index keys. |
| * |
| * Revision History: |
| * |
| * Date Name Revision |
| * ------- --------------- ------------------------------ |
| * 24May99 Matthew Rivas Created |
| * |
| * Copyright 1999, Atlantic Aerospace Electronics Corp. |
| */ |
| |
| #include <assert.h> /* for assert() */ |
| #include <stdlib.h> /* for NULL definition */ |
| #include "dataManagement.h" /* for primitive type definitions */ |
| #include "index.h" /* for IndexEntry definition */ |
| #include "indexKey.h" /* for IndexKey definition */ |
| |
| /* |
| * Macro definitions for MAX and MIN for use of this file only. |
| */ |
| #define MAX( a, b ) ( (a) > (b) ? (a) : (b) ) |
| #define MIN( a, b ) ( (a) < (b) ? (a) : (b) ) |
| |
| /* |
| * |
| * Name: keyUnion |
| * Input: index key, A |
| * index key, B |
| * Output: index key, U |
| * Return: void |
| * Description: Determines the union of two index keys. The union is |
| * defined as the minimal bounding index key which completely |
| * encloses the two input index keys, i.e., a "bounding-box". |
| * The "box" is found by simply determining the minimum and |
| * maximum values for each dimension of the index key. The |
| * values of the output key U do not require "past" values |
| * from A or B, so the pointers can be "reused", i.e., the |
| * routine can be called as keyUnion( A, B, B ) which will |
| * determine the key union of A and B and places the result |
| * in B. |
| * Calls: |
| * System: |
| * Author: M.L.Rivas |
| * |
| * Revision History: |
| * |
| * Date Name Revision |
| * ------- --------------- ------------------------------ |
| * 24May99 Matthew Rivas Created |
| * |
| * Copyright 1999, Atlantic Aerospace Electronics Corp. |
| */ |
| |
| void keyUnion( IndexKey *A, /* first entry for key union */ |
| IndexKey *B, /* second entry for key union */ |
| IndexKey *U ) /* union of entries A and B */ |
| { /* beginning of keyUnion() */ |
| |
| assert( A ); |
| assert( B ); |
| assert( U ); |
| |
| /* |
| * Find max and min for each dimension of index keys |
| */ |
| U->lower.T = MIN( A->lower.T, B->lower.T ); |
| U->lower.X = MIN( A->lower.X, B->lower.X ); |
| U->lower.Y = MIN( A->lower.Y, B->lower.Y ); |
| U->lower.Z = MIN( A->lower.Z, B->lower.Z ); |
| U->upper.T = MAX( A->upper.T, B->upper.T ); |
| U->upper.X = MAX( A->upper.X, B->upper.X ); |
| U->upper.Y = MAX( A->upper.Y, B->upper.Y ); |
| U->upper.Z = MAX( A->upper.Z, B->upper.Z ); |
| |
| return; |
| } /* end of keyUnion() */ |
| |
| /* |
| * |
| * Name: keysUnion |
| * Input: index entry list, I |
| * Output: index key, U |
| * Return: void |
| * Description: Determines the union of the index keys of a list of index |
| * entries. The union is defined as the minimal bounding |
| * index key which completely encloses all of the input index |
| * keys, i.e., a "bounding-box". The "box" is found by simply |
| * determing the minimum and maximum values for each dimension |
| * of the index key. |
| * Calls: |
| * keyUnion() |
| * System: |
| * Author: M.L.Rivas |
| * |
| * Revision History: |
| * |
| * Date Name Revision |
| * ------- --------------- ------------------------------ |
| * 24May99 Matthew Rivas Created |
| * |
| * Copyright 1999, Atlantic Aerospace Electronics Corp. |
| */ |
| |
| void keysUnion( IndexEntry *I, /* list of index entries */ |
| IndexKey *U ) /* union of entries of I */ |
| { /* beginning of keysUnion() */ |
| |
| assert( I ); |
| assert( U ); |
| |
| /* |
| * Loop over entry list. Must set value of index key U to some value to |
| * prevent NaN or uninitialized memory issues. Setting it to the key of |
| * the first index entry is sufficient and saves one keyUnion calculation. |
| */ |
| *U = I->key; |
| for ( I = I->next; I != NULL; I = I->next ) { |
| /* |
| * Expand hyper-cube bounding "box" by determining union of key of |
| * current index entry with current index key. This will always |
| * "expand" the box or leave it unaltered. |
| */ |
| keyUnion( &(I->key), U, U ); |
| } /* end of loop for I */ |
| |
| return; |
| } /* end of keysUnion() */ |