// Wavelet Analysis Tool
//--------------------------------------------------------------------
// Implementation of 
// Bi-othogonal wavelet transforms using lifting scheme 
// References:
//   A.Cohen, I.Daubechies, J.Feauveau Bases of compactly supported wavelets
//   Comm. Pure. Appl. Math. 45, 485-560, 1992
//   W. Sweldens - Building your own wavelets at home
//--------------------------------------------------------------------
//$Id: Biorthogonal.hh,v 0.2 2001/08/06 19:37:00 klimenko Exp $

#define BIORTHOGONAL_CC

#include "Biorthogonal.hh"

namespace datacondAPIwat {

// constructors

template<class DataType_t> Biorthogonal<DataType_t>::
Biorthogonal(const Wavelet &w) : 
WaveDWT<DataType_t>(w) 
{ 
   setFilter();
}

template<class DataType_t> Biorthogonal<DataType_t>::
Biorthogonal(const Biorthogonal<DataType_t> &w) : 
WaveDWT<DataType_t>(w) 
{ 
   setFilter();
}

template<class DataType_t> Biorthogonal<DataType_t>::
Biorthogonal(int m=4, int tree=0, enum BORDER border=B_CYCLE) :
WaveDWT<DataType_t>(m,m,tree,border) 
{
   setFilter();
}

// destructor
template<class DataType_t>
Biorthogonal<DataType_t>::~Biorthogonal()
{ 
   if(hp) delete [] hp;
   if(hu) delete [] hu;
}

// clone
template<class DataType_t>
Biorthogonal<DataType_t>* Biorthogonal<DataType_t>::Clone() const
{
  return new Biorthogonal<DataType_t>(*this);
}

// set filter and wavelet type
template<class DataType_t>
void Biorthogonal<DataType_t>::setFilter()
{ 
   int n = m_H;

   n = (n>>1)<<1;
   if(n < 2) n=4;
   if(n > 30) n=20;   // limit is due to the unrolled code length

   hp=new double[n];
   hu=new double[n];

   for(int i=0; i<n; i++) 
   {
      hp[i] = Lagrange(n,i,0.);
      hu[i] = 0.5*hp[i];
   }
   m_WaveType = BIORTHOGONAL;
}


// decompose function does one step of forward transformation.
// <level> input parameter is the level to be transformed
// <layer> input parameter is the layer to be transformed.
template<class DataType_t>
void Biorthogonal<DataType_t>::decompose(int level,int layer)
{
   level++;                          // increment level (next level now)

//------------------ border handling-----------------------
// sample index     0.......nL............nR....nS-1
// detail samples:  L L L L M M ..... M M R R R R
// approx samples: L L L L M M ..... M M R R R R
// L,R - samples affected by borders
//   M - not affected samples
//---------------------------------------------------------

   int nS = nWWS>>level;     // nS - number of samples in the layer
   int nL = m_H/2;	         // nL - left border index (beginning of M samples)
   int nR = nS-m_H/2;	         // nR - right border index (beginning of R samples)
   int nM = (nS - m_H)<<level;   // (number of M samples)<<level  

   double *pY = new double[m_H]; // Y array for interpolation
   double *pX = new double[m_H]; // X array for interpolation

   register int stride = 1<<level; // stride parameter

   int i,j,k;
   double data = 0.;
   
   register double *h;		 // pointer to filter coefficient
   register double sum = 0.;     // filter sum

   register DataType_t *dataL;   // pointer to left data sample
   register DataType_t *dataR;   // pointer to right data sample
   
   DataType_t *dataA, *dataD; 

   dataA=pWWS+getOffset(level,layer<<1);     // pointer to approximation layer
   dataD=pWWS+getOffset(level,(layer<<1)+1); // pointer to detail layer

//------------------PREDICT BEGIN--------------------------

// left border

  if (m_Border==B_POLYNOM) {
     for(i=0; i<m_H; i++){
	*(pY+i) = *(dataA + i*stride/2);
	*(pX+i) = i;
     }
  }

  for(i=0; i<nL; i++) {                    // i - detail index
     h = hp;
     sum = 0.;

     for(j=0; j<m_H; j+=1) {               // j - filter index
	k = i+j-nL;                        // k - approximation index

	if(k<0){

	   switch (m_Border) {

	      case B_PAD_ZERO :            // pad zero
		 data = 0.;
		 break;

	      case B_MIRROR :              // mirror data
		 data = *(dataA + ((-k)<<level));
		 break;

	      case B_PAD_EDGE :            // pad by edge values
		 data = *dataA;
		 break;

	      case B_POLYNOM :             // polynomial extrapolation
		 data = Nevill(m_H, pX, pY, 2.*k);
		 break;

	      default :                    // cycle data
		 data = *(dataA + ((k+nS)<<level));
		 break;
	   }
	}
	else {data = *(dataA + (k<<level));}

	sum += *(h++) * data;
     }
     
     *dataD -= sum;
      dataD += stride;
  }

// regular case (no borders)

  j = (m_H-1)<<level;

  for(i=0; i<=nM; i+=stride) {
    dataL = dataA+i;
    dataR = dataL+j;
                
    h=hp;

/* 
    sum=0.;
    do sum+=*(h++)*(*data1+*data2);
    while((data1+=lst)<(data2-=lst));
*/

// unrolled loop, maximum filter length is 30;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto P0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto P0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto P0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto P0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto P0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto P0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto P0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto P0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto P0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto P0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto P0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto P0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto P0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto P0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto P0;

P0: *dataD -= sum;
     dataD += stride;
  }

// right border

  if (m_Border==B_POLYNOM) {
     for(i=0; i<m_H; i++){
	*(pY+i) = *(dataA + nR*stride + i*stride/2);
	*(pX+i) = 2*nR+i-1;
     }
  }

  for(i=nR; i<nS; i++) {                   // i - detail index
     h = hp;
     sum = 0.;

     for(j=0; j<m_H; j+=1) {               // j - filter index
	k = i+j;                           // k - approximation index

	if(k>=nS){
	
	   switch (m_Border) {

	      case B_PAD_ZERO :            // pad zero
		 data = 0.;
		 break;

	      case B_MIRROR :              // mirror data
		 data = *(dataA + ((2*nS-k-2)<<level));
		 break;

	      case B_PAD_EDGE :            // pad by edge values
		 data = *(dataA + ((nS-1)<<level));
		 break;

	      case B_POLYNOM :             // polynomial extrapolation
		 data = Nevill(m_H, pX, pY, 2.*k);
		 break;

	      default :                    // cycle data
		 data = *(dataA + ((k-nS)<<level));
		 break;		
	   }
	}
	else { data = *(dataA + (k<<level)); }

	sum += *(h++) * data;
     }
     
     *dataD -= sum;
      dataD += stride;
  }

//-------------------PREDICT END-----------------------------

//-------------------UPDATE BEGIN----------------------------

   dataD=pWWS+getOffset(level,(layer<<1)+1); // pointer to detail layer

// left border

  if (m_Border==B_POLYNOM) {
     for(i=0; i<m_H; i++){
	*(pY+i) = *(dataA + i*stride/2);
	*(pX+i) = i;
     }
  }

  for(i=0; i<nL; i++) {                    // i - approximation index
     h = hu;
     sum = 0.;

     for(j=0; j<m_H; j+=1) {               // j - filter index
	k = i+j-nL;                        // k - detail index

	if(k<0){

	   switch (m_Border) {

	      case B_PAD_ZERO :            // pad zero
		 data = 0.;
		 break;

	      case B_MIRROR :              // mirror data
		 data = *(dataD + ((-k)<<level));
		 break;

	      case B_PAD_EDGE :            // pad by edge values
		 data = *dataD;
		 break;

	      case B_POLYNOM :             // polynomial extrapolation
		 data = Nevill(m_H, pX, pY, 2.*k+1.);
		 break;

	      default :                    // cycle data
		 data = *(dataD + ((k+nS)<<level));
		 break;
	   }
	}
	else { data = *(dataD + (k<<level)); }

	sum += *(h++) * data;
     }
     
     *dataA += sum;
      dataA += stride;
  }

// regular case (no borders)

  j = (m_H-1)<<level;

  for(i=0; i<=nM; i+=stride) {
    dataL = dataD+i;
    dataR = dataL+j;
                
    h=hu;

/* 
    sum=0.;
    do sum+=*(h++)*(*dataL+*dataR);
    while((dataL+=lst)<(dataR-=lst));
*/

// unrolled loop, maximum filter length is 30;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto U0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto U0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto U0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto U0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto U0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto U0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto U0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto U0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto U0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto U0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto U0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto U0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto U0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto U0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto U0;

U0: *dataA += sum;
     dataA += stride;
  }

// right border

  if (m_Border==B_POLYNOM) {
     for(i=0; i<m_H; i++){
	*(pY+i) = *(dataA + i*stride/2);
	*(pX+i) = 2*nR+i-1;
     }
  }

  for(i=nR; i<nS; i++) {                   // i - detail index
     h = hu;
     sum = 0.;

     for(j=0; j<m_H; j+=1) {               // j - filter index
	k = i+j;                           // k - approximation index

	if(k>=nS){

	   switch (m_Border) {

	      case B_PAD_ZERO :            // pad zero
		 data = 0.;
		 break;

	      case B_MIRROR :              // mirror data
		 data = *(dataD + ((2*nS-k-2)<<level));
		 break;

	      case B_PAD_EDGE :            // pad by edge values
		 data = *(dataD + ((nS-1)<<level));
		 break;

	      case B_POLYNOM :             // polynomial extrapolation
		 data = Nevill(m_H, pX, pY, 2.*k+1);
		 break;

	      default :                    // cycle data
		 data = *(dataD + ((k-nS)<<level));
		 break;

	   }
	}
	else { data = *(dataD + (k<<level)); }

	sum += *(h++) * data;
     }
     
     *dataA += sum;
      dataA += stride;
  }

//-------------------UPDATE END-----------------------------

}

// reconstruct function does one step of inverse transformation.
// <level> input parameter is the level to be reconstructed
// <layer> input parameter is the layer to be reconstructed.
template<class DataType_t>
void Biorthogonal<DataType_t>::reconstruct(int level,int layer)
{
   level++;                      // current level

//------------------ border handling-----------------------
// sample index     0.......nL............nR....nS-1
// detail samples:  L L L L M M ..... M M R R R R
// approx samples: L L L L M M ..... M M R R R R
// L,R - samples affected by borders
//   M - not affected samples
//---------------------------------------------------------

   int nS = nWWS>>level;         // nS - number of samples in the layer
   int nL = m_H/2;	         // nL - left border index (beginning of M samples)
   int nR = nS-m_H/2;	         // nR - right border index (beginning of R samples)
   int nM = (nS - m_H)<<level;   // (number of M samples)<<level  

   double *pY = new double[m_H]; // Y array for interpolation
   double *pX = new double[m_H]; // X array for interpolation

   register int stride = 1<<level; // stride parameter

   int i,j,k;
   double data = 0.;
   
   register double *h;		 // pointer to filter coefficient
   register double sum = 0.;     // filter sum

   register DataType_t *dataL;   // pointer to left data sample
   register DataType_t *dataR;   // pointer to right data sample
   
   DataType_t *dataA, *dataD; 

   dataA=pWWS+getOffset(level,layer<<1);     // pointer to approximation layer
   dataD=pWWS+getOffset(level,(layer<<1)+1); // pointer to detail layer

//-------------------UPDATE BEGIN----------------------------

// left border

  if (m_Border==B_POLYNOM) {
     for(i=0; i<m_H; i++){
	*(pY+i) = *(dataA + i*stride/2);
	*(pX+i) = i;
     }
  }

  for(i=0; i<nL; i++) {                    // i - approximation index
     h = hu;
     sum = 0.;

     for(j=0; j<m_H; j+=1) {               // j - filter index
	k = i+j-nL;                        // k - detail index

	if(k<0){

	   switch (m_Border) {

	      case B_PAD_ZERO :            // pad zero
		 data = 0.;
		 break;

	      case B_MIRROR :              // mirror data
		 data = *(dataD + ((-k)<<level));
		 break;

	      case B_PAD_EDGE :            // pad by edge values
		 data = *dataD;
		 break;

	      case B_POLYNOM :             // polynomial extrapolation
		 data = Nevill(m_H, pX, pY, 2.*k+1.);
		 break;

	      default :                    // cycle data
		 data = *(dataD + ((k+nS)<<level));
		 break;
	   }
	}
	else { data = *(dataD + (k<<level)); }

	sum += *(h++) * data;
     }
     
     *dataA -= sum;
      dataA += stride;
  }

// regular case (no borders)

  j = (m_H-1)<<level;

  for(i=0; i<=nM; i+=stride) {
    dataL = dataD+i;
    dataR = dataL+j;
                
    h=hu;

/* 
    sum=0.;
    do sum+=*(h++)*(*dataL+*dataR);
    while((dataL+=lst)<(dataR-=lst));
*/

// unrolled loop, maximum filter length is 30;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto U0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto U0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto U0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto U0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto U0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto U0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto U0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto U0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto U0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto U0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto U0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto U0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto U0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto U0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto U0;

U0: *dataA -= sum;
     dataA += stride;
  }

// right border

  if (m_Border==B_POLYNOM) {
     for(i=0; i<m_H; i++){
	*(pY+i) = *(dataA + i*stride/2);
	*(pX+i) = 2*nR+i-1;
     }
  }

  for(i=nR; i<nS; i++) {                   // i - detail index
     h = hu;
     sum = 0.;

     for(j=0; j<m_H; j+=1) {               // j - filter index
	k = i+j;                           // k - approximation index

	if(k>=nS){

	   switch (m_Border) {

	      case B_PAD_ZERO :            // pad zero
		 data = 0.;
		 break;

	      case B_MIRROR :              // mirror data
		 data = *(dataD + ((2*nS-k-2)<<level));
		 break;

	      case B_PAD_EDGE :            // pad by edge values
		 data = *(dataD + ((nS-1)<<level));
		 break;

	      case B_POLYNOM :             // polynomial extrapolation
		 data = Nevill(m_H, pX, pY, 2.*k+1);
		 break;

	      default :                    // cycle data
		 data = *(dataD + ((k-nS)<<level));
		 break;
	   }
	}
	else { data = *(dataD + (k<<level)); }

	sum += *(h++) * data;
     }
     
     *dataA -= sum;
      dataA += stride;
  }

//-------------------UPDATE END-----------------------------

//------------------PREDICT BEGIN--------------------------

   dataA=pWWS+getOffset(level,(layer<<1)); // pointer to approximation layer

// left border

  if (m_Border==B_POLYNOM) {
     for(i=0; i<m_H; i++){
	*(pY+i) = *(dataA + i*stride/2);
	*(pX+i) = i;
     }
  }

  for(i=0; i<nL; i++) {                    // i - detail index
     h = hp;
     sum = 0.;

     for(j=0; j<m_H; j+=1) {               // j - filter index
	k = i+j-nL;                        // k - approximation index

	if(k<0){

	   switch (m_Border) {

	      case B_PAD_ZERO :            // pad zero
		 data = 0.;
		 break;

	      case B_MIRROR :              // mirror data
		 data = *(dataA + ((-k)<<level));
		 break;

	      case B_PAD_EDGE :            // pad by edge values
		 data = *dataA;
		 break;

	      case B_POLYNOM :             // polynomial extrapolation
		 data = Nevill(m_H, pX, pY, 2.*k);
		 break;

	      default :                    // cycle data
		 data = *(dataA + ((k+nS)<<level));
		 break;
	   }
	}
	else {data = *(dataA + (k<<level));}

	sum += *(h++) * data;
     }
     
     *dataD += sum;
      dataD += stride;
  }

// regular case (no borders)

  j = (m_H-1)<<level;

  for(i=0; i<=nM; i+=stride) {
    dataL = dataA+i;
    dataR = dataL+j;
                
    h=hp;

/* 
    sum=0.;
    do sum+=*(h++)*(*data1+*data2);
    while((data1+=lst)<(data2-=lst));
*/

// unrolled loop, maximum filter length is 30;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto P0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto P0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto P0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto P0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto P0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto P0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto P0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto P0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto P0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto P0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto P0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto P0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto P0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto P0;
    sum += *(h++) * (*dataL + *dataR);
    if ((dataL+=stride) >= (dataR-=stride)) goto P0;

P0: *dataD += sum;
     dataD += stride;
  }

// right border

  if (m_Border==B_POLYNOM) {
     for(i=0; i<m_H; i++){
	*(pY+i) = *(dataA + nR*stride + i*stride/2);
	*(pX+i) = 2*nR+i-1;
     }
  }

  for(i=nR; i<nS; i++) {                   // i - detail index
     h = hp;
     sum = 0.;

     for(j=0; j<m_H; j+=1) {               // j - filter index
	k = i+j;                           // k - approximation index

	if(k>=nS){
	
	   switch (m_Border) {

	      case B_PAD_ZERO :            // pad zero
		 data = 0.;
		 break;

	      case B_MIRROR :              // mirror data
		 data = *(dataA + ((2*nS-k-2)<<level));
		 break;

	      case B_PAD_EDGE :            // pad by edge values
		 data = *(dataA + ((nS-1)<<level));
		 break;

	      case B_POLYNOM :             // polynomial extrapolation
		 data = Nevill(m_H, pX, pY, 2.*k);
		 break;

	      default :                    // cycle data
		 data = *(dataA + ((k-nS)<<level));
		 break;
	   }
	}
	else { data = *(dataA + (k<<level)); }

	sum += *(h++) * data;
     }
     
     *dataD += sum;
      dataD += stride;
  }

//-------------------PREDICT END-----------------------------
}

// instantiations

#define CLASS_INSTANTIATION(class_) template class Biorthogonal< class_ >;

CLASS_INSTANTIATION(float)
CLASS_INSTANTIATION(double)
//CLASS_INSTANTIATION(std::complex<float>)
//CLASS_INSTANTIATION(std::complex<double>)

#undef CLASS_INSTANTIATION

template Biorthogonal<float>::
Biorthogonal(const Biorthogonal<float> &);
template Biorthogonal<double>::
Biorthogonal(const Biorthogonal<double> &);

}  // end namespace datacondAPIwat