---

poly.h

Go to the documentation of this file.

#ifndef _POLY_H_
#define _POLY_H_


#include <vector>

#include "liftbase.h"
#include "polyinterp.h"



template<class T>
class poly : public liftbase<T, double> {

public:
  poly() {}
  ~poly() {}
  // declare, but don't define to disallow copy constructor
  poly(const poly &rhs );

private:
  typedef enum { numPts = 4 } bogus;
  polyinterp fourPtInterp;

  void fill( T &vec, double d[], int N, int start )
  {
    int n = numPts;
    if (n > N)
      n = N;
    int end = start + n;
    int j = 0;

    for (int i = start; i < end; i++) {
      d[j] = vec[i];
      j++;
    }
  } // fill

protected:

  void update( T &vec, int N, transDirection direction )
  {
    int half = N >> 1;

    for (int i = 0; i < half; i++) {
      int j = i + half;
      double updateVal = vec[j] / 2.0;

      if (direction == forward) {
        vec[i] = (vec[i] + vec[j])/2;
      }
      else if (direction == inverse) {
        vec[i] = (2 * vec[i]) - vec[j];
      }
      else {
        printf("update: bad direction value\n");
      }
    }
  } // update



  void predict( T &vec, int N, transDirection direction )
  {
    int half = N >> 1;
    double d[4];

    for (int i = 0; i < half; i++) {
      double predictVal;

      if (i == 0) {
        if (half == 1) {
          // e.g., N == 2, and we use Haar interpolation
          predictVal = vec[0];
        }
        else {
          fill( vec, d, N, 0 );
          predictVal = fourPtInterp.interpPoint( 0.5, half, d );
        }
      }
      else if (i == 1) {
        predictVal = fourPtInterp.interpPoint( 1.5, half, d );
      }
      else if (i == half-2) {
        predictVal = fourPtInterp.interpPoint( 2.5, half, d );
      }
      else if (i == half-1) {
        predictVal = fourPtInterp.interpPoint( 3.5, half, d );
      }
      else {
        fill( vec, d, N, i-1);
        predictVal = fourPtInterp.interpPoint( 1.5, half, d );
      }

      int j = i + half;
      if (direction == forward) {
        vec[j] = vec[j] - predictVal;
      }
      else if (direction == inverse) {
        vec[j] = vec[j] + predictVal;
      }
      else {
        printf("interp: bad direction value\n");
        break;
      }
    } // for
  } // predict

public:

  void forwardStep( T& vec, const int n )
  {
    split( vec, n );
    update( vec, n, forward );
    predict( vec, n, forward );
  } // forwardStep

  virtual void inverseStep( T& vec, const int n )
  {
    predict( vec, n, inverse );
    update( vec, n, inverse );
    merge( vec, n );
  }

}; // poly


#endif

---