---

tacLUTableBlock.h

Go to the documentation of this file.

/*******************************************************************************
* E.S.O. - VLT project
*
* "@(#) $Id: tacLUTableBlock.h,v 1.34 2003/11/27 21:41:52 vltsccm Exp $"
*
* who       when      what
* --------  --------  ----------------------------------------------
* bbauvir   21/03/01  created
*/

#ifndef TAC_LUTABLEBLOCK_H
#define TAC_LUTABLEBLOCK_H

/************************************************************************
 *  tacLUTableBlock.h - This file provides the interface to the Look-Up 
 *                      Table Block abstract class. Any specification of 
 *                      this class must include this header file.
 *
 *----------------------------------------------------------------------
 */

/* 
 * System Headers
 */

/* 
 * Local Headers
 */

#include "tacStdBlock.h"

/*
 * Constants
 */

/*
 * The constructor expects the size of the function table (unsigned short)
 */

#define tacLUTABLE_EXPECTED_PARAM 1    

/*
 * Child function block is allowed to store parameters starting from this index
 */

#define tacLUTABLE_FREE_PARAM_INDEX 1    

/* 
 * Types
 */

typedef struct {
  double x;
  double y;
}tacLUTABLE_DOUBLET;

typedef struct {
  unsigned short size;
  unsigned short index;
  tacLUTABLE_DOUBLET* function;
}tacLUTABLE;

/*
 * Macros
 */

#define tacLUTableGetTable(pSelf) ((tacLUTABLE*) ((pSelf)->parameter))

#define tacLUTableSetPoint(pTable, index, abs, ord) \
  {                                                 \
    pTable->function[index].x = abs;                \
    pTable->function[index].y = ord;                \
  }

#define tacLUTableGetPoint(pTable, index, abs, ord) \
  {                                                 \
    abs = pTable->function[index].x;                \
    ord = pTable->function[index].y;                \
  }

/*
 * Global variables
 */

/*
 * Functions
 */

/*
 * Note: Routines called from within the algorithm must be declared with
 *       static __inline__ <prototype>
 */

STATUS tacLUTableBlockConstructor(tacSTDBLOCK* pSelf, tacSTDBLOCK_PARAM* parameter, tacERROR* error);
STATUS tacLUTableBlockGetParameter(tacSTDBLOCK* pSelf, tacSTDBLOCK_PARAM* parameter, tacERROR* error);
void tacLUTableBlockAlgorithm(tacSTDBLOCK* pSelf);
void tacLUTableBlockDestructor(tacSTDBLOCK* pSelf);

STATUS tacLUTableCreateTable(tacLUTABLE* pTable, unsigned short size);
void tacLUTableRemoveTable(tacLUTABLE* pTable);

/*
 * Note: This routine returns the index of the highest input of the 
 *       tabulated function inferior to the passed input value 
 *       See Numerical recipes in C (3.4 How to search an ordered table)
 */

static __inline__ unsigned short tacLUTableHunt (tacLUTABLE* pTable, double input)
{
  unsigned short increment;
  unsigned short lower, higher, middle;

  /*
   * Notes: - We make the assumption that the input points are sorted in 
   *          monotonically increasing order
   *        - Due to the slow dynamics of input signals, we use the last 
   *          index found as input guess
   *        - Bissection does not support input values out of the table
   *          boundaries
   */

  /* Set the hunting increment */
  increment = 1;

  /* Set the previous known position */
  lower = pTable->index;

  if (input >= pTable->function[lower].x)    /* Hunt upwards */
    {
      higher = lower + 1;

      while (input >= pTable->function[higher].x)
  {
    lower = higher;
    increment <<= 1;
    higher = lower + increment;

    if (higher >= pTable->size)    /* End of table */
      {
        higher = pTable->size;
        break;
      }
  }
    }
  else    /* Hunt downwards */
    {
      higher = lower;
      lower -= 1;

      while (input <= pTable->function[lower].x)
  {
    higher = lower;
    increment <<= 1;
    lower = higher - increment;

#if 0    /* Cannot perform this test - lower is unsigned */
    if (lower <= 0)    /* End of table */
      {
        lower = 0;
        break;
      }
#else
    if (increment >= higher)    /* End of table */
      {
        lower = 0;
        break;
      }
#endif
  }
    }

  /*
   * Hunt is done ...
   * ... start bissection 
   */

  while ((higher - lower) != 1)
    {
      middle = (higher + lower) >> 1;

      if (input >= pTable->function[middle].x)
  {
    lower = middle;
  }
      else
  {
    higher = middle;
  }
    }

  /* Store found index for further use */
  pTable->index = lower;

  return lower;
}

static __inline__ double tacLUTableInterpolate (tacLUTABLE* pTable, double input)
{
  unsigned short index = 0;

  double y0, y1;
  double x0, x1;

  if (input <= pTable->function[0].x)
    {
      return (pTable->function[0].y);
    }
  else if (input >= pTable->function[(pTable->size - 1)].x)
    {
      return (pTable->function[(pTable->size - 1)].y);
    }
  else
    {
      index = tacLUTableHunt(pTable, input);

      x0 = pTable->function[index].x;
      y0 = pTable->function[index].y;
      x1 = pTable->function[index+1].x;
      y1 = pTable->function[index+1].y;

      /* Linear interpolation */
      return (y0 + ((input - x0) / (x1 - x0) * (y1 - y0)));
    }
}

#endif 

---