plData.h

/*=============================================================================
 * Product        : OpenPL
 * File           : plData.h (before kplData.h)
 * Author         : Juan-Manuel Ahuactzin
 * Creation       : Fri Mar 16 12:56:22 2001
 *
 *=============================================================================
 *     (c) Copyright 2000, Centre National de la Recherche Scientifique,
 *                              all rights reserved
 *=============================================================================
 *
 *------------------------- Description ---------------------------------------
 *   
 *   
 *-----------------------------------------------------------------------------
 */

#ifndef _plData_h_
#define _plData_h_

#include <plMath.h>
#include <plError.h>



//=============================================================================
class plData 
{
public:

//=============================================================================
/* Type of information stored in a plData */
enum plData_type {kplNIL,           // no type defined
                 kplINTEGER,       // integer type
                 kplFLOAT};


enum plCoupleDataType {
  INT_INT =      0,  // 00 integer and integer
  INT_FLOAT =    1,  // 01 integer and float
  FLOAT_INT =   2,  // 10 float and integer
  FLOAT_FLOAT =  3}; 

protected:
  void Output(ostream &out) const;
  void Input(istream& in);

private:
  union {
    long int int_value;
    
    plFloat float_value;
    
  };
  
  plData_type data_type;

  inline plCoupleDataType couple_type(const plData& data) const
  {
    plCoupleDataType type1,type2, result;

    // first data is integer
    if (data_type == plData::kplINTEGER)
      type1 = plData::INT_INT;
    // first data is float
    else //if (data_type == plData::kplFLOAT)
      type1 = plData::FLOAT_INT;
 
    // second data is integer
    if (data.data_type == plData::kplINTEGER)
      type2 = plData::INT_INT;
    // second data is float
    else //if (data.data_type == plData::kplFLOAT)
      type2 = plData::INT_FLOAT;
    
    // return the data type of the couple by combining the two types
    // (note that it is an or operator)
    result = plCoupleDataType (type1 | type2);
    
    return(result);
  }

public:
  
  inline plData();
  inline plData(int v);
  inline plData(unsigned int v);
  inline plData(long int v);
  inline plData(unsigned long int v);
  inline plData(float v);
  inline plData(double v);
#ifndef RAVI_INTERFACE
  inline plData(long double v);
#endif

  inline plData& operator=(const plData &data);
  inline plData& operator=(int v);
  inline plData& operator=(long int v);
  inline plData& operator=(unsigned int v);
  inline plData& operator=(unsigned long int v);
  inline plData& operator=(float v);
  inline plData& operator=(double v);

#ifndef RAVI_INTERFACE
  inline plData& operator=(long double v);
#endif


  inline bool operator==(const plData &data) const;
  inline bool operator==(int int_value) const;
  inline bool operator==(unsigned int int_value) const;
  inline bool operator==(long int int_value) const;
  inline bool operator==(unsigned long int int_value) const;
  inline bool operator==( float float_value) const;
  inline bool operator==( double double_value) const;
#ifndef RAVI_INTERFACE
  inline bool operator==( long double ldouble_value) const;
#endif

  inline bool operator!=(const plData &data) const {return !(*this == data);}
  inline bool operator!=(int int_valuev) const {return !(*this == int_valuev);}
  inline bool operator!=(unsigned int int_valuev) const {return !(*this == int_valuev);}
  inline bool operator!=(long int int_valuev) const {return !(*this == int_valuev);}
  inline bool operator!=(unsigned long int int_valuev) const {return !(*this == int_valuev);}
  inline bool operator!=( float float_valuev) const {return !(*this == float_valuev);}
  inline bool operator!=( double double_valuev) const {return !(*this == double_valuev);}
#ifndef RAVI_INTERFACE

  inline bool operator!=( long double ldouble_value) const {return !(*this == ldouble_value);}
#endif

  inline bool operator>(const plData &data) const;
  inline bool operator>(int int_value) const;
  inline bool operator>(unsigned int int_value) const;
  inline bool operator>(long int int_value) const;
  inline bool operator>(unsigned long int int_value) const;
  inline bool operator>(float float_value) const;
  inline bool operator>(double double_value) const;
#ifndef RAVI_INTERFACE

  inline bool operator>(long double ldouble_value) const;
#endif


  inline bool operator>=(const plData &data) const;
  inline bool operator>=(int int_value) const;
  inline bool operator>=(unsigned int int_value) const;
  inline bool operator>=(long int int_value) const;
  inline bool operator>=(unsigned long int int_value) const;
  inline bool operator>=(float float_value) const;
  inline bool operator>=(double double_value) const;
#ifndef RAVI_INTERFACE
  bool operator>=(long double ldouble_value) const;
#endif  

  inline bool operator<(const plData &data) const;
  inline bool operator<(int int_value) const;
  inline bool operator<(unsigned int int_value) const;
  inline bool operator<(long int int_value) const;
  inline bool operator<(unsigned long int int_value) const;
  inline bool operator<(float float_value) const;
  inline bool operator<(double double_value) const;
#ifndef RAVI_INTERFACE
  inline bool operator<(long double ldouble_value) const;
#endif


  inline bool operator<=(const plData &data) const;
  inline bool operator<=(int int_value) const;
  inline bool operator<=(unsigned int int_value) const;
  inline bool operator<=(long int int_value) const;
  inline bool operator<=(unsigned long int int_value) const;
  inline bool operator<=(float float_value) const;
  inline bool operator<=(double double_value) const;

#ifndef RAVI_INTERFACE
  inline bool operator<=(long double ldouble_value) const;
#endif

  inline plData operator*(const plData &data) const;
  inline plData operator*(int data) const;
  inline plData operator*(unsigned int data) const;
  inline plData operator*(long int data) const;
  inline plData operator*(unsigned long int data) const;
  inline plData operator*(float v) const;
  inline plData operator*(double v) const;
#ifndef RAVI_INTERFACE

  inline plData operator*(long double v) const;
#endif

  inline plData operator/(const plData &data) const;
  inline plData operator/(int data) const;
  inline plData operator/(unsigned int data) const;
  inline plData operator/(long int data) const;
  inline plData operator/(unsigned long int data) const;
  inline plData operator/(float v) const;
  plData operator/(double v) const;
#ifndef RAVI_INTERFACE

  inline plData operator/(long double v) const;
#endif

  inline plData operator+(const plData &data) const;
  inline plData operator+(int data) const;
  inline plData operator+(unsigned int data) const;
  inline plData operator+(long int data) const;
  inline plData operator+(unsigned long int data) const;
  inline plData operator+(float v) const;
  inline plData operator+(double v) const;
#ifndef RAVI_INTERFACE

  plData operator+(long double v) const;
#endif


  inline plData operator-(const plData &data) const;
  inline plData operator-(int data) const;
  inline plData operator-(unsigned int data) const;
  inline plData operator-(long int data) const;
  inline plData operator-(unsigned long int data) const;
  inline plData operator-(float v) const;
  inline plData operator-(double v) const;
#ifndef RAVI_INTERFACE

  inline plData operator-(long double v) const;
#endif

  inline long int operator%(int number); 
  inline long int operator%(unsigned int number); 
  inline long int operator%(long int number); 

  

#ifndef RAVI_INTERFACE

  inline operator float() const;

  inline operator double() const;

  inline operator long double() const;

  inline operator int() const;

  inline operator unsigned int() const;

  inline operator long int() const;

#endif

  friend class kpl1dGauss;
  friend class kplInteger;
  friend class kplArray;
  friend class kplKLocker;
  friend class kplReal;
  friend class kplSFLocker;
  friend class kplSKFLocker;
  friend class kplSKLocker;
  friend class kplGauss;
  friend class kplBellShape;
  friend class kplConditionalBellShape;
  friend class kplMemory;
  friend class kpl1dHistogram;
  friend class kplHistogram;
  friend class kplGlobalMetropolisSampler;
  friend class kplKernelTable;
  friend class kplTwinCndKernel;
  friend class kplCndKernelFromKernel;
  friend class kplCUniform;
  friend class kplSparseType;
  friend class kplPoisson;
  friend class kplGamma;
  friend class kpl1DGamma;
  friend class plDataArray;
  friend class plKernel;
  friend class plDataValues;
  friend class plValues;
  friend class kplConditionalHistogramA;
  friend class kplConditionalHistogram;
  friend class kplAnonymousKernel;
  friend class kplKamelExpression;
  friend class kplConditional1dGauss; 
  friend class kplConditionalGauss;
  friend class kplConditional1dGaussA;
  friend class kplConditional1dGaussB;
  friend class kplConditional1dGaussC;
  friend class kplConditional1dGaussD;
  friend class kplConditional1dGaussE;
  friend class kplConditional1dGaussF;
  friend class kplConditional1dGaussG;
  friend class kplConditionalGaussD;
  friend class kplConditionalGaussE;
  friend class kplConditionalGaussF;
  friend class kplConditionalGaussG;
  friend class kplConditionalBellShapeA;
  friend class kplConditionalBellShapeB;
  friend class kplConditionalBellShapeC;
  friend class kplConditionalBellShapeD;
  friend class kplConditionalBellShapeE;
  friend class kplConditionalBellShapeF;
  friend class kplConditionalBellShapeG;
  friend class kplDirac;
  friend class kplGaAlgorithm;
  friend class kplIneqConstraint;
  friend class plIneqConstraint;
  friend class kplFunctionalDirac;
  friend class kplLogNormal;

  friend inline plData toData(const float& v);
  friend inline plData toData(const int& v);

#ifndef RAVI_INTERFACE

  friend inline plData operator*(int number, const plData& data);
  friend inline plData operator*(unsigned int number, const plData& data);
  friend inline plData operator*(long int number, const plData& data);
  friend inline plData operator*(unsigned long int number, const plData& data);
  friend inline plData operator*(float number, const plData& data);
  friend inline plData operator*(double number, const plData& data);
  friend inline plData operator*(long double number, const plData& data);


  friend inline plData operator+(int number, const plData& data);
  friend inline plData operator+(unsigned int number, const plData& data);
  friend inline plData operator+(long int number, const plData& data);
  friend inline plData operator+(unsigned long int number, const plData& data);
  friend inline plData operator+(float number, const plData& data);
  friend inline plData operator+(double number, const plData& data);
  friend inline plData operator+(long double number, const plData& data);

  friend inline plData operator-(int number, const plData& data);
  friend inline plData operator-(unsigned int number, const plData& data);
  friend inline plData operator-(long int number, const plData& data);
  friend inline plData operator-(unsigned long int number, const plData& data);
  friend inline plData operator-(float number, const plData& data);
  friend inline plData operator-(double number, const plData& data);
  friend inline plData operator-(long double number, const plData& data);

  //void set_forced(const plData &data);

  friend ostream &operator<<(ostream &out, const plData &data){
    data.Output(out);
    return out;
  }

  friend istream& operator>>(istream& in, plData &data) {
    data.Input(in);
    return in;
  }

#endif
};


#ifndef RAVI_INTERFACE

inline plData operator*(int number, const plData& data);
inline plData operator*(unsigned int number, const plData& data);
inline plData operator*(long int number, const plData& data);
inline plData operator*(unsigned long int number, const plData& data);
inline plData operator*(float number, const plData& data);
inline plData operator*(double number, const plData& data);
inline plData operator*(long double number, const plData& data);


inline plData operator+(int number, const plData& data);
inline plData operator+(unsigned int number, const plData& data);
inline plData operator+(long int number, const plData& data);
inline plData operator+(unsigned long int number, const plData& data);
inline plData operator+(float number, const plData& data);
inline plData operator+(double number, const plData& data);
inline plData operator+(long double number, const plData& data);



inline plData operator-(int number, const plData& data);
inline plData operator-(unsigned int number, const plData& data);
inline plData operator-(long int number, const plData& data);
inline plData operator-(unsigned long int number, const plData& data);
inline plData operator-(float number, const plData& data);
inline plData operator-(double number, const plData& data);
inline plData operator-(long double number, const plData& data);

inline plData toData(const float& v);
inline plData toData(const int& v);








//=============================================================================
inline plData::plData()
{
  data_type = plData::kplNIL;
}
//=============================================================================
inline plData::plData(int v)
{
  data_type = plData::kplINTEGER;
  int_value = v;

}
//=============================================================================
inline plData::plData(unsigned int v)
{
  data_type = plData::kplINTEGER;
  int_value = v;

}
//=============================================================================
inline plData::plData(long int v)
{
  data_type = plData::kplINTEGER;
  int_value = v;

}
//=============================================================================
inline plData::plData(unsigned long int v)
{
  data_type = plData::kplINTEGER;
  int_value = v;

}

//=============================================================================
inline plData::plData(float v)
{
  data_type = plData::kplFLOAT;
  float_value = v;
}
//=============================================================================
inline plData::plData(double v)
{
  data_type = plData::kplFLOAT;
  float_value = v;
}
//=============================================================================
inline plData::plData(long double v)
{
  data_type = plData::kplFLOAT;
  float_value = v;
}

//=============================================================================
inline plData& plData::operator=(const plData &data)
{
  //This is the case when we have a new plData and we copy on it the
  //content of another plData
  if(data_type == plData::kplNIL)
    data_type  = data.data_type;

  switch(couple_type(data))
    {
    case plData::INT_INT:
      int_value = (long int) data.int_value;
      break;
    case plData::INT_FLOAT:
      int_value = (long int) data.float_value;
      break;
    case plData::FLOAT_INT:
      float_value = data.int_value;
      break;
    case plData::FLOAT_FLOAT:
      float_value = data.float_value;
      break;
    default:
      throw plError(2," plData operator = plData ");
    }
    

  return(*this);
}


//=============================================================================
inline plData& plData::operator=(int v)
{
  switch (data_type)
    {
    case plData::kplINTEGER :
      int_value = v;
      break;
    case plData::kplFLOAT:
      float_value = v;
      break;
    default:
      throw plError(2,"plData operator = int");
    }
  return *this;
}

//=============================================================================
inline plData& plData::operator=(long int v)
{
  switch (data_type)
    {
    case plData::kplINTEGER :
      int_value = v;
      break;
    case plData::kplFLOAT:
      float_value = v;
      break;
    default:
      throw plError(2,"plData operator = long int");
    }
  return *this;
}

//=============================================================================
inline plData& plData::operator=(unsigned int v)
{
  switch (data_type)
    {
    case plData::kplINTEGER :
      int_value = v;
      break;
    case plData::kplFLOAT:
      float_value = v;
      break;
    default:
      throw plError(2,"plData operator  = unsigned int");
    }
  return *this;
}

//=============================================================================
inline plData& plData::operator=(unsigned long int v)
{
  switch (data_type)
    {
    case plData::kplINTEGER :
      int_value = v;
      break;
    case plData::kplFLOAT:
      float_value = v;
      break;
    default:
      throw plError(2,"plData operator = unsigned long int");
    }
  return *this;
}
//=============================================================================
inline plData& plData::operator=(float v)
{
  switch (data_type)
    {
    case plData::kplINTEGER :
      int_value = int(v);
      break;
    case plData::kplFLOAT:
      float_value = v;
      break;
    default:
      throw plError(2,"plData operator = float");
    }
  return *this;
}
//=============================================================================
inline plData& plData::operator=(double v)
{
  switch (data_type)
    {
    case plData::kplINTEGER :
      int_value = int(v);
      break;
    case plData::kplFLOAT:
      float_value = v;
      break;
    default: 
      throw plError(2,"plData operator = double");
    }
  return *this;
}

//=============================================================================
inline plData& plData::operator=(long double v)
{

  switch (data_type)
    {
    case plData::kplINTEGER :
      int_value = int(v);
      break;
    case plData::kplFLOAT:
      float_value = v;
      break;
    default:
      throw plError(2,"plData operator = long double");
    }
  return *this;
}

//=============================================================================
inline bool plData::operator==(const plData &data) const 
{
  
  switch(couple_type(data))
    {
    case plData::INT_INT:
      return(int_value==data.int_value);
      break;
    case plData::INT_FLOAT:
      return(int_value==data.float_value);
      break;
    case plData::FLOAT_INT:
      return(float_value==data.int_value);
      break;
    case plData::FLOAT_FLOAT:
      return(float_value==data.float_value);
      break;
    default:
      throw plError(2," plData operator == plData");
      return false;
    }

}

//=============================================================================
inline bool plData::operator==(int _int_value) const
{
  switch (data_type)
    {
    case plData::kplINTEGER :
      return(int_value == _int_value);
      break;
    case plData::kplFLOAT:
      return(float_value == _int_value);
      break;
    default:
      throw plError(2,"plData operator == int");
      return false;
    }
}

//=============================================================================
inline bool plData::operator==(unsigned int _int_value) const
{
  switch (data_type)
    {
    case plData::kplINTEGER :
      return(int_value == (long int) _int_value);
      break;
    case plData::kplFLOAT:
      return(float_value == _int_value);
      break;
    default:
      throw plError(2,"plData operator == unsigned int");
      return false;
    }
}

//=============================================================================
inline bool plData::operator==(long int _int_value) const
{
  switch (data_type)
    {
    case plData::kplINTEGER :
      return(int_value == _int_value);
      break;
    case plData::kplFLOAT:
      return(float_value == _int_value);
      break;
    default:
      throw plError(2,"plData operator == long int");
      return false;
    }
}
//=============================================================================
inline bool plData::operator==(unsigned long int _int_value) const
{
  switch (data_type)
    {
    case plData::kplINTEGER :
      return(int_value == (long int) _int_value);
      break;
    case plData::kplFLOAT:
      return(float_value == _int_value);
      break;
    default:
      throw plError(2,"plData operator == unsigned long int");
      return false;
    }
}

//=============================================================================
inline bool plData::operator==(float _float_value) const
{
  switch (data_type)
    {
    case plData::kplINTEGER :
      return(int_value == _float_value);
      break;
    case plData::kplFLOAT:
      return(float_value == _float_value);
      break;
    default:
      throw plError(2,"plData operator == float");
      return false;
    }
}
//=============================================================================
inline bool plData::operator==(double _float_value) const
{
  switch (data_type)
    {
    case plData::kplINTEGER :
      return(int_value == _float_value);
      break;
    case plData::kplFLOAT:
      return(float_value == _float_value);
      break;
    default:
      throw plError(2,"plData operator == double");
      return false;
    }
}
//=============================================================================
inline bool plData::operator==(long double _float_value) const
{
  switch (data_type)
    {
    case plData::kplINTEGER :
      return(int_value == _float_value);
      break;
    case plData::kplFLOAT:
      return(float_value == _float_value);
      break;
    default:
      throw plError(2,"plData operator == long double");
      return false;
    }
}

//=============================================================================
inline bool plData::operator>(const plData &data) const 
{

  switch(couple_type(data))
    {
    case plData::INT_INT:
      return(int_value>data.int_value);
      break;
    case plData::INT_FLOAT:
      return(int_value>data.float_value);
      break;
    case plData::FLOAT_INT:
      return(float_value>data.int_value);
      break;
    case plData::FLOAT_FLOAT:
      return(float_value>data.float_value);
      break;
    default:
      throw plError(2,"plData operator > plData");
      return false;
    }

}

//=============================================================================
inline bool plData::operator>(int _int_value) const
{
  switch (data_type)
    {
    case plData::kplINTEGER :
      return(int_value > _int_value);
      break;
    case plData::kplFLOAT:
      return(float_value > _int_value);
      break;
    default:
      throw plError(2,"plData operator > int");
      return false;
    }
}
//=============================================================================
inline bool plData::operator>(unsigned int _int_value) const
{
  switch (data_type)
    {
    case plData::kplINTEGER :
      return(int_value > (long int)_int_value);
      break;
    case plData::kplFLOAT:
      return(float_value > _int_value);
      break;
    default:
      throw plError(2,"plData > unsigned int");
      return false;
    }
}
//=============================================================================
inline bool plData::operator>(long int _int_value) const
{
  switch (data_type)
    {
    case plData::kplINTEGER :
      return(int_value > _int_value);
      break;
    case plData::kplFLOAT:
      return(float_value > _int_value);
      break;
    default:
      throw plError(2,"plData > long int");
      return false;
    }
}

//=============================================================================
inline bool plData::operator>(unsigned long int _int_value) const
{
  switch (data_type)
    {
    case plData::kplINTEGER :
      return(int_value > (long int) _int_value);
      break;
    case plData::kplFLOAT:
      return(float_value > _int_value);
      break;
    default:
      throw plError(2,"plData > unsigned long int");
      return false;
    }
}

//=============================================================================
inline bool plData::operator>(float _float_value) const
{
  switch (data_type)
    {
    case plData::kplINTEGER :
      return(int_value > _float_value);
      break;
    case plData::kplFLOAT:
      return(float_value > _float_value);
      break;
    default:
      throw plError(2,"plData > float");
      return false;
    }
}
//=============================================================================
inline bool plData::operator>(double _float_value) const
{
  switch (data_type)
    {
    case plData::kplINTEGER :
      return(int_value > _float_value);
      break;
    case plData::kplFLOAT:
      return(float_value > _float_value);
      break;
    default:
      throw plError(2,"plData > double");
      return false;
    }
}
//=============================================================================
inline bool plData::operator>(long double _float_value) const
{
  switch (data_type)
    {
    case plData::kplINTEGER :
      return(int_value > _float_value);
      break;
    case plData::kplFLOAT:
      return(float_value > _float_value);
      break;
    default:
      throw plError(2,"plData > long double");
      return false;
    }
}


//=============================================================================
inline bool plData::operator>=(const plData &data) const 
{

  switch(couple_type(data))
    {
    case plData::INT_INT:
      return(int_value>=data.int_value);
      break;
    case plData::INT_FLOAT:
      return(int_value>=data.float_value);
      break;
    case plData::FLOAT_INT:
      return(float_value>=data.int_value);
      break;
    case plData::FLOAT_FLOAT:
      return(float_value>=data.float_value);
      break;
    default:
      throw plError(2," plData >= plData");
      return false;
    }
  
}

//=============================================================================
inline bool plData::operator>=(int _int_value) const
{
  switch (data_type)
    {
    case plData::kplINTEGER :
      return(int_value >= _int_value);
      break;
    case plData::kplFLOAT:
      return(float_value >= _int_value);
      break;
    default:
      throw plError(2,"plData >= int");
      return false;
    }
}

//=============================================================================
inline bool plData::operator>=(unsigned int _int_value) const
{
  switch (data_type)
    {
    case plData::kplINTEGER :
      return(int_value >= (long int) _int_value);
      break;
    case plData::kplFLOAT:
      return(float_value >= _int_value);
      break;
    default:
      throw plError(2,"plData >= unsigned int");
      return false;
    }
}
//=============================================================================
inline bool plData::operator>=(long int _int_value) const
{
  switch (data_type)
    {
    case plData::kplINTEGER :
      return(int_value >= _int_value);
      break;
    case plData::kplFLOAT:
      return(float_value >= _int_value);
      break;
    default:
      throw plError(2,"plData >= long int");
      return false;
    }
}
//=============================================================================
inline bool plData::operator>=(unsigned long int _int_value) const
{
  switch (data_type)
    {
    case plData::kplINTEGER :
      return(int_value >= (long int) _int_value);
      break;
    case plData::kplFLOAT:
      return(float_value >= _int_value);
      break;
    default:
      throw plError(2,"plData >= unsigned long int");
      return false;
    }
}


//=============================================================================
inline bool plData::operator>=(float _float_value) const
{
  switch (data_type)
    {
    case plData::kplINTEGER :
      return(int_value >= _float_value);
      break;
    case plData::kplFLOAT:
      return(float_value >= _float_value);
      break;
    default:
      throw plError(2,"plData >= float");
      return false;
    }
}

//=============================================================================
inline bool plData::operator>=(double _float_value) const
{
  switch (data_type)
    {
    case plData::kplINTEGER :
      return(int_value >= _float_value);
      break;
    case plData::kplFLOAT:
      return(float_value >= _float_value);
      break;
    default:
      throw plError(2,"plData >= double");
      return false;
    }
}

//=============================================================================
inline bool plData::operator>=(long double _float_value) const
{
  switch (data_type)
    {
    case plData::kplINTEGER :
      return(int_value >= _float_value);
      break;
    case plData::kplFLOAT:
      return(float_value >= _float_value);
      break;
    default:
      throw plError(2,"plData >= long double");
      return false;
    }
}

//=============================================================================
inline bool plData::operator<(const plData &data) const 
{

  switch(couple_type(data))
    {
    case plData::INT_INT:
      return(int_value<data.int_value);
      break;
    case plData::INT_FLOAT:
      return(int_value<data.float_value);
      break;
    case plData::FLOAT_INT:
      return(float_value<data.int_value);
      break;
    case plData::FLOAT_FLOAT:
      return(float_value<data.float_value);
      break;
    default:
      throw plError(2,"plData < plData ");
      return false;
    }
  
}
//=============================================================================
inline bool plData:: operator<(int _int_value) const
{
  switch (data_type)
    {
    case plData::kplINTEGER :
      return(int_value < _int_value);
      break;
    case plData::kplFLOAT:
      return(float_value < _int_value);
      break;
    default:
      throw plError(2,"plData < int");
      return false;
    }
}
//=============================================================================
inline bool plData:: operator<(unsigned int _int_value) const
{
  switch (data_type)
    {
    case plData::kplINTEGER :
      return(int_value < (long int)_int_value);
      break;
    case plData::kplFLOAT:
      return(float_value < _int_value);
      break;
    default:
      throw plError(2,"plData < unsigned int");
      return false;
    }
}

//=============================================================================
inline bool plData:: operator<(long int _int_value) const
{
  switch (data_type)
    {
    case plData::kplINTEGER :
      return(int_value < _int_value);
      break;
    case plData::kplFLOAT:
      return(float_value < _int_value);
      break;
    default:
      throw plError(2,"plData < long int");
      return false;
    }
}


//=============================================================================
inline bool plData:: operator<(unsigned long int _int_value) const
{
  switch (data_type)
    {
    case plData::kplINTEGER :
      return(int_value < (long int)_int_value);
      break;
    case plData::kplFLOAT:
      return(float_value < _int_value);
      break;
    default:
      throw plError(2,"plData < unsigned long int");
      return false;
    }
}

//=============================================================================
inline bool plData::operator<(float _float_value) const
{
  switch (data_type)
    {
    case plData::kplINTEGER :
      return(int_value < _float_value);
      break;
    case plData::kplFLOAT:
      return(float_value < _float_value);
      break;
    default:
      throw plError(2,"plData < float");
      return false;
    }

}


//=============================================================================
inline bool plData::operator<(double _float_value) const
{
  switch (data_type)
    {
    case plData::kplINTEGER :
      return(int_value < _float_value);
      break;
    case plData::kplFLOAT:
      return(float_value < _float_value);
      break;
    default:
      throw plError(2,"plData < double");
      return false;
    }

}


//=============================================================================
inline bool plData::operator<(long double _float_value) const
{
  switch (data_type)
    {
    case plData::kplINTEGER :
      return(int_value < _float_value);
      break;
    case plData::kplFLOAT:
      return(float_value < _float_value);
      break;
    default:
      throw plError(2,"plData < long double");
      return false;
    }

}


//=============================================================================
inline bool plData::operator<=(const plData &data) const 
{

  
  switch(couple_type(data))
    {
    case plData::INT_INT:
      return(int_value<=data.int_value);
      break;
    case plData::INT_FLOAT:
      return(int_value<=data.float_value);
      break;
    case plData::FLOAT_INT:
      return(float_value<=data.int_value);
      break;
    case plData::FLOAT_FLOAT:
      return(float_value<=data.float_value);
      break;
    default:
      throw plError(2," plData <= plData ");
      return false;
    }
}

//=============================================================================
inline bool plData::operator<=(int _int_value) const
{
  switch (data_type)
    {
    case plData::kplINTEGER :
      return(int_value <= _int_value);
      break;
    case plData::kplFLOAT:
      return(float_value <= _int_value);
      break;
    default:
      throw plError(2,"plData <= int");
      return false;
    }
}
//=============================================================================
inline bool plData::operator<=(unsigned int _int_value) const
{
  switch (data_type)
    {
    case plData::kplINTEGER :
      return(int_value <= (long int) _int_value);
      break;
    case plData::kplFLOAT:
      return(float_value <= _int_value);
      break;
    default:
      throw plError(2,"plData <= unsigned int");
      return false;
    }
}
//=============================================================================
inline bool plData::operator<=(long int _int_value) const
{
  switch (data_type)
    {
    case plData::kplINTEGER :
      return(int_value <= _int_value);
      break;
    case plData::kplFLOAT:
      return(float_value <= _int_value);
      break;
    default:
      throw plError(2,"plData <= long int");
      return false;
    }
}
//=============================================================================
inline bool plData::operator<=(unsigned long int _int_value) const
{
  switch (data_type)
    {
    case plData::kplINTEGER :
      return(int_value <= (long int) _int_value);
      break;
    case plData::kplFLOAT:
      return(float_value <= _int_value);
      break;
    default:
      throw plError(2,"plData <= unsigned long int");
      return false;
    }
}

//=============================================================================
inline bool plData::operator<=(float _float_value) const
{
  switch (data_type)
    {
    case plData::kplINTEGER :
      return(int_value <= _float_value);
      break;
    case plData::kplFLOAT:
      return(float_value <= _float_value);
      break;
    default:
      throw plError(2,"plData <= float");
      return false;
    }
}

//=============================================================================
inline bool plData::operator<=(double _float_value) const
{
  switch (data_type)
    {
    case plData::kplINTEGER :
      return(int_value <= _float_value);
      break;
    case plData::kplFLOAT:
      return(float_value <= _float_value);
      break;
    default:
      throw plError(2,"plData <= double");
      return false;
    }
}

//=============================================================================
inline bool plData::operator<=(long double _float_value) const
{
  switch (data_type)
    {
    case plData::kplINTEGER :
      return(int_value <= _float_value);
      break;
    case plData::kplFLOAT:
      return(float_value <= _float_value);
      break;
    default:
      throw plError(2,"plData <= long double");
      return false;
    }
}


//=============================================================================
inline plData plData::operator*(const plData &data) const 
{
  switch (couple_type(data))
    {
    case plData::INT_INT:
      return(int_value*data.int_value);
      break;
    case plData::INT_FLOAT:
      return(int_value*data.float_value);
      break;
    case plData::FLOAT_INT:
      return(float_value*data.int_value);
      break;
    case plData::FLOAT_FLOAT:
      return(float_value*data.float_value);
      break;
    default:
      throw plError(2,"plData * plData");
    }

}

//=============================================================================
inline plData plData::operator*(int data) const 
{
  switch (data_type)
    {
    case plData::kplINTEGER:
      return(int_value*data);
      break;
    case plData::kplFLOAT:
      return(float_value*data);
      break;
    default:
      throw plError(2,"plData * int");
    }
}

//=============================================================================
inline plData plData::operator*(unsigned int data) const 
{
  switch (data_type)
    {
    case plData::kplINTEGER:
      return(int_value*data);
      break;
    case plData::kplFLOAT:
      return(float_value*data);
      break;
    default:
      throw plError(2,"plData * unsigned int");
    }
}

//=============================================================================
inline plData plData::operator*(long int data) const 
{
 
  switch (data_type)
    {
    case plData::kplINTEGER:
      return(int_value*data);
      break;
    case plData::kplFLOAT:
      return(float_value*data);
      break;
    default:
      throw plError(2,"plData * long int");
    }

}

//=============================================================================
inline plData plData::operator*(unsigned long int data) const 
{ 
  switch (data_type)
    {
    case plData::kplINTEGER:
      return(int_value*data);
      break;
    case plData::kplFLOAT:
      return(float_value*data);
      break;
    default:
      throw plError(2,"plData * unsigned long int");
    }

}


//=============================================================================
inline plData plData::operator*(float data) const 
{ 
  switch (data_type)
    {
    case plData::kplINTEGER:
      return(int_value*data);
      break;
    case plData::kplFLOAT:
      return(float_value*data);
      break;
    default:
      throw plError(2,"plData * float");
    }
}
//=============================================================================
inline plData plData::operator*(double data) const 
{  
  switch (data_type)
    {
    case plData::kplINTEGER:
      return(int_value*data);
      break;
    case plData::kplFLOAT:
      return(float_value*data);
      break;
    default:
      throw plError(2,"plData * double");
    }

}

//=============================================================================
inline plData plData::operator*(long double data) const 
{  
  switch (data_type)
    {
    case plData::kplINTEGER:
      return(int_value*data);
      break;
    case plData::kplFLOAT:
      return(float_value*data);
      break;
    default:
      throw plError(2,"plData * long double");
    }
}
//=============================================================================
inline plData plData::operator/(const plData &data) const 
{ 
  switch (couple_type(data))
    {
    case plData::INT_INT:
      return(int_value/data.int_value);
      break;
    case plData::INT_FLOAT:
      return(int_value/data.float_value);
      break;
    case plData::FLOAT_INT:
      return(float_value/data.int_value);
      break;
    case plData::FLOAT_FLOAT:
      return(float_value/data.float_value);
      break;
    default:
      throw plError(2,"plData / plData");
    }
  
}

//=============================================================================
inline plData plData::operator/(int data) const 
{ 
  switch (data_type)
    {
    case plData::kplINTEGER:
      return(int_value/data);
      break;
    case plData::kplFLOAT:
      return(float_value/data);
      break;
    default:
      throw plError(2,"plData / int");
    }

}

//=============================================================================
inline plData plData::operator/(unsigned int data) const 
{ 
  switch (data_type)
    {
    case plData::kplINTEGER:
      return(int_value/data);
      break;
    case plData::kplFLOAT:
      return(float_value/data);
      break;
    default:
      throw plError(2,"plData / unsigned int");
    }
}

//=============================================================================
inline plData plData::operator/(long int data) const 
{ 
  switch (data_type)
    {
    case plData::kplINTEGER:
      return(int_value/data);
      break;
    case plData::kplFLOAT:
      return(float_value/data);
      break;
    default:
      throw plError(2,"plData / long int");
    }

}

//=============================================================================
inline plData plData::operator/(unsigned long int data) const 
{ 
  switch (data_type)
    {
    case plData::kplINTEGER:
      return(int_value/data);
      break;
    case plData::kplFLOAT:
      return(float_value/data);
      break;
    default:
      throw plError(2,"plData / unsigned long int");
    }

}


//=============================================================================
inline plData plData::operator/(float data) const 
{ 
  switch (data_type)
    {
    case plData::kplINTEGER:
      return(int_value/data);
      break;
    case plData::kplFLOAT:
      return(float_value/data);
      break;
    default:
      throw plError(2,"plData / float");
    }
}

//=============================================================================
inline plData plData::operator/(double data) const 
{
  switch (data_type)
    {
    case plData::kplINTEGER:
      return(int_value/data);
      break;
    case plData::kplFLOAT:
      return(float_value/data);
      break;
    default:
      throw plError(2,"plData / double");
    }
}

//=============================================================================
inline plData plData::operator/(long double data) const 
{
  switch (data_type)
    {
    case plData::kplINTEGER:
      return(int_value/data);
      break;
    case plData::kplFLOAT:
      return(float_value/data);
      break;
    default:
      throw plError(2,"plData / long double");
    }
}

//=============================================================================
inline plData plData::operator+(const plData &data) const 
{ 
  switch (couple_type(data))
    {
    case plData::INT_INT:
      return(int_value+data.int_value);
      break;
    case plData::INT_FLOAT:
      return(int_value+data.float_value);
      break;
    case plData::FLOAT_INT:
      return(float_value+data.int_value);
      break;
    case plData::FLOAT_FLOAT:
      return(float_value+data.float_value);
      break;
    default:
      throw plError(2,"plData + plData");
    }

}

//=============================================================================
inline plData plData::operator+(int data) const 
{
  switch (data_type)
    {
    case plData::kplINTEGER:
      return(int_value+data);
      break;
    case plData::kplFLOAT:
      return(float_value+data);
      break;
    default:
      throw plError(2,"plData + int");
    }  
}

//=============================================================================
inline plData plData::operator+(unsigned int data) const 
{
  switch (data_type)
    {
    case plData::kplINTEGER:
      return(int_value+data);
      break;
    case plData::kplFLOAT:
      return(float_value+data);
      break;
    default:
      throw plError(2,"plData + int");
    }
  
}
//=============================================================================
inline plData plData::operator+(long int data) const 
{ 
  switch (data_type)
    {
    case plData::kplINTEGER:
      return(int_value+data);
      break;
    case plData::kplFLOAT:
      return(float_value+data);
      break;
    default:
      throw plError(2,"plData + long int");
    }  
}

//=============================================================================
inline plData plData::operator+(unsigned long int data) const 
{
  switch (data_type)
    {
    case plData::kplINTEGER:
      return(int_value+data);
      break;
    case plData::kplFLOAT:
      return(float_value+data);
      break;
    default:
      throw plError(2,"plData + unsigned long int");
    }  
}

//=============================================================================
inline plData plData::operator+(float data) const 
{ 
  switch (data_type)
    {
    case plData::kplINTEGER:
      return(int_value+data);
      break;
    case plData::kplFLOAT:
      return(float_value+data);
      break;
    default:
      throw plError(2,"plData + float");
    }
}
//=============================================================================
inline plData plData::operator+(double data) const 
{ 
  switch (data_type)
    {
    case plData::kplINTEGER:
      return(int_value+data);
      break;
    case plData::kplFLOAT:
      return(float_value+data);
      break;
    default:
      throw plError(2,"plData + double");
    }

}

//=============================================================================
inline plData plData::operator+(long double data) const 
{
  switch (data_type)
    {
    case plData::kplINTEGER:
      return(int_value+data);
      break;
    case plData::kplFLOAT:
      return(float_value+data);
      break;
    default:
      throw plError(2,"plData + long double");
    }
}

//=============================================================================
inline plData plData::operator-(const plData &data) const
{
  switch (couple_type(data))
    {
    case plData::INT_INT:
      return(int_value-data.int_value);
      break;
    case plData::INT_FLOAT:
      return(int_value-data.float_value);
      break;
    case plData::FLOAT_INT:
      return(float_value-data.int_value);
      break;
    case plData::FLOAT_FLOAT:
      return(float_value-data.float_value);
      break;
    default:
      throw plError(2,"plData - plData");
    }
   
}

//=============================================================================
inline plData plData::operator-(int data) const 
{
  switch (data_type)
    {
    case plData::kplINTEGER:
      return(int_value-data);
      break;
    case plData::kplFLOAT:
      return(float_value-data);
      break;
    default:
      throw plError(2,"plData - int");
    }
 
}

//=============================================================================
inline plData plData::operator-(unsigned int data) const 
{
  switch (data_type)
    {
    case plData::kplINTEGER:
      return(int_value-data);
      break;
    case plData::kplFLOAT:
      return(float_value-data);
      break;
    default:
      throw plError(2,"plData - unsigned int");
    }
 
}

//=============================================================================
inline plData plData::operator-(long int data) const 
{ 
  switch (data_type)
    {
    case plData::kplINTEGER:
      return(int_value-data);
      break;
    case plData::kplFLOAT:
      return(float_value-data);
      break;
    default:
      throw plError(2,"plData - long int");
    } 
}
//=============================================================================
inline plData plData::operator-(unsigned long int data) const 
{
  switch (data_type)
    {
    case plData::kplINTEGER:
      return(int_value-data);
      break;
    case plData::kplFLOAT:
      return(float_value-data);
      break;
    default:
      throw plError(2,"plData - unsigned long int");
    }
 
}


//=============================================================================
inline plData plData::operator-(float data) const 
{
  switch (data_type)
    {
    case plData::kplINTEGER:
      return(int_value-data);
      break;
    case plData::kplFLOAT:
      return(float_value-data);
      break;
    default:
      throw plError(2,"plData - float");
    } 
}

//=============================================================================
inline plData plData::operator-(double data) const 
{ 
  switch (data_type)
    {
    case plData::kplINTEGER:
      return(int_value-data);
      break;
    case plData::kplFLOAT:
      return(float_value-data);
      break;
    default:
      throw plError(2,"plData - double");
    } 
}
//=============================================================================
inline plData plData::operator-(long double data) const 
{  
  switch (data_type)
    {
    case plData::kplINTEGER:
      return(int_value-data);
      break;
    case plData::kplFLOAT:
      return(float_value-data);
      break;
    default:
      throw plError(2,"plData - long double");
    } 
}



//=============================================================================
inline long int plData::operator%(int number)
{  
  long int result;
  
  switch (data_type)
    {
    case plData::kplINTEGER:
      result = int_value % number;
      break;
    case plData::kplFLOAT:
      result = (long int) float_value;
      result = result % number;
      break;
    default:
      throw plError(2,"operator plData % int");
    }
  return(result);
}

//=============================================================================
inline long int plData::operator%(unsigned int number)
{
  long int result;
  switch (data_type)
    {
    case plData::kplINTEGER:
      result = int_value % number;
      break;
    case plData::kplFLOAT:
      result = (long int) float_value;
      result = result % number;
      break;
    default:
      throw plError(2,"operator plData % unsigned int");
    }
  return(result);
}

//=============================================================================
inline long int plData::operator%(long int number)
{
  long int result;
  switch (data_type)
    {
    case plData::kplINTEGER:
      result = int_value % number;
      break;
    case plData::kplFLOAT:
      result = (long int) float_value;
      result = result % number;
      break;
    default:
      throw plError(2,"operator plData % long int");
    }
  return(result);
}

//=============================================================================
inline plData::operator long double() const 
{
  long double res;
  switch (data_type){
  case plData::kplINTEGER:
    res = (long double)int_value;
    break;
  case plData::kplFLOAT:
    res = float_value;
    break;
  default:
    throw plError(2,"Conversion to long double");
  }
  
  return res;
}

//=============================================================================
inline plData::operator float() const 
{
  float res;
  switch (data_type){
  case plData::kplINTEGER:
    res = (float)int_value;
    break;
  case plData::kplFLOAT:
    res = float_value;
    break;
  default:
    throw plError(2,"Conversion to float");
  }
  
  return res;
}

//=============================================================================
inline plData::operator double() const 
{
  double res;
  switch (data_type){
  case plData::kplINTEGER:
    res = (double)int_value;
    break;
  case plData::kplFLOAT:
    res = float_value;
    break;
  default:
    throw plError(2,"Conversion to double");
  }
  
  return res;
}


//=============================================================================
inline 
plData::operator int() const
{
  int res;
  switch (data_type){
  case plData::kplINTEGER:
    res = int_value;
    break;
  case plData::kplFLOAT:
    res = (int)float_value;
    break;
  default:
    throw plError(2,"Conversion to int");
  }
  
  return res;
}

//=============================================================================
inline plData::operator unsigned int() const
{
  unsigned int res;
  switch (data_type){
  case plData::kplINTEGER:
    res = int_value;
    break;
  case plData::kplFLOAT:
    res = (int)float_value;
    break;
  default:
    throw plError(2,"Conversion to unsigned int");
  }
  
  return res;
}

//=============================================================================
inline plData::operator long int() const
{
  long int res;
  switch (data_type){
  case plData::kplINTEGER:
    res = int_value;
    break;
  case plData::kplFLOAT:
    res = (int)float_value;
    break;
  default:
    throw plError(2,"Conversion to long int");
  }
  
  return res;
}

//=============================================================================
inline plData operator*(int number, const plData& data) 
{
  switch (data.data_type)
    {
    case plData::kplINTEGER:
      return(number*data.int_value);
      break;
    case plData::kplFLOAT:
      return(number*data.float_value);
      break;
    default:
      throw plError(2,"int * plData");
    }
}

//=============================================================================
inline plData operator*(unsigned int number, const plData& data) 
{
  switch (data.data_type)
    {
    case plData::kplINTEGER:
      return(number*data.int_value);
      break;
    case plData::kplFLOAT:
      return(number*data.float_value);
      break;
    default:
      throw plError(2,"unsigned int * plData");
    }

}

//=============================================================================
inline plData operator*(long int number, const plData& data) 
{ 
  switch (data.data_type)
    {
    case plData::kplINTEGER:
      return(number*data.int_value);
      break;
    case plData::kplFLOAT:
      return(number*data.float_value);
      break;
    default:
      throw plError(2,"long int * plData");
    }
}

//=============================================================================
inline plData operator*(unsigned long int number, const plData& data) 
{
  switch (data.data_type)
    {
    case plData::kplINTEGER:
      return(number*data.int_value);
      break;
    case plData::kplFLOAT:
      return(number*data.float_value);
      break;
    default:
      throw plError(2,"unsigned long int * plData");
    }
  
}

//=============================================================================
inline plData operator*(float number, const plData& data) 
{
  switch (data.data_type)
    {
    case plData::kplINTEGER:
      return(number*data.int_value);
      break;
    case plData::kplFLOAT:
      return(number*data.float_value);
      break;
    default:
      throw plError(2,"float * plData");
    }  
}

//=============================================================================
inline plData operator*(double number, const plData& data) 
{
  switch (data.data_type)
    {
    case plData::kplINTEGER:
      return(number*data.int_value);
      break;
    case plData::kplFLOAT:
      return(number*data.float_value);
      break;
    default:
      throw plError(2,"double * plData");
    }  
}

//=============================================================================
inline plData operator*(long double number, const plData& data) 
{
  switch (data.data_type)
    {
    case plData::kplINTEGER:
      return(number*data.int_value);
      break;
    case plData::kplFLOAT:
      return(number*data.float_value);
      break;
    default:
      throw plError(2,"long double * plData");
    }  
}

//=============================================================================
inline plData operator+(int number, const plData& data) 
{ 
  switch (data.data_type)
    {
    case plData::kplINTEGER:
      return(number+data.int_value);
      break;
    case plData::kplFLOAT:
      return(number+data.float_value);
      break;
    default:
      throw plError(2,"int + plData");
    }
}
//=============================================================================
inline plData operator+(unsigned int number, const plData& data) 
{ 
  switch (data.data_type)
    {
    case plData::kplINTEGER:
      return(number+data.int_value);
      break;
    case plData::kplFLOAT:
      return(number+data.float_value);
      break;
    default:
      throw plError(2,"unsigned int + plData");
    }
}
//=============================================================================
inline plData operator+(long int number, const plData& data) 
{ 
  switch (data.data_type)
    {
    case plData::kplINTEGER:
      return(number+data.int_value);
      break;
    case plData::kplFLOAT:
      return(number+data.float_value);
      break;
    default:
      throw plError(2,"long int + plData");
    }
}
//=============================================================================
inline plData operator+(unsigned long int number, const plData& data) 
{ 
  switch (data.data_type)
    {
    case plData::kplINTEGER:
      return(number+data.int_value);
      break;
    case plData::kplFLOAT:
      return(number+data.float_value);
      break;
    default:
      throw plError(2,"unsigned long int + plData");
    }
}

//=============================================================================
inline plData operator+(float number, const plData& data) 
{
  switch (data.data_type)
    {
    case plData::kplINTEGER:
      return(number+data.int_value);
      break;
    case plData::kplFLOAT:
      return(number+data.float_value);
      break;
    default:
      throw plError(2,"float + plData");
    } 
}

//=============================================================================
inline plData operator+(double number, const plData& data) 
{  
  switch (data.data_type)
    {
    case plData::kplINTEGER:
      return(number+data.int_value);
      break;
    case plData::kplFLOAT:
      return(number+data.float_value);
      break;
    default:
      throw plError(2,"double + plData");
    } 
}

//=============================================================================
inline plData operator+(long double number, const plData& data) 
{ 
  switch (data.data_type)
    {
    case plData::kplINTEGER:
      return(number+data.int_value);
      break;
    case plData::kplFLOAT:
      return(number+data.float_value);
      break;
    default:
      throw plError(2,"long double + plData");
    } 
}

//=============================================================================
inline plData operator-(int number, const plData& data) 
{
  switch (data.data_type)
    {
    case plData::kplINTEGER:
      return(number-data.int_value);
      break;
    case plData::kplFLOAT:
      return(number-data.float_value);
      break;
    default:
      throw plError(2,"int - plData");
    }
}
//=============================================================================
inline plData operator-(unsigned int number, const plData& data) 
{  
  switch (data.data_type)
    {
    case plData::kplINTEGER:
      return(number-data.int_value);
      break;
    case plData::kplFLOAT:
      return(number-data.float_value);
      break;
    default:
      throw plError(2,"unsigned int - plData");
    }
}
//=============================================================================
inline plData operator-(long int number, const plData& data) 
{
  switch (data.data_type)
    {
    case plData::kplINTEGER:
      return(number-data.int_value);
      break;
    case plData::kplFLOAT:
      return(number-data.float_value);
      break;
    default:
      throw plError(2,"long int - plData");
    }
}
//=============================================================================
inline plData operator-(unsigned long int number, const plData& data) 
{
  switch (data.data_type)
    {
    case plData::kplINTEGER:
      return(number-data.int_value);
      break;
    case plData::kplFLOAT:
      return(number-data.float_value);
      break;
    default:
      throw plError(2,"unsigned long int - plData");
    }
}

//=============================================================================
inline plData operator-(float number, const plData& data) 
{
  switch (data.data_type)
    {
    case plData::kplINTEGER:
      return(number-data.int_value);
      break;
    case plData::kplFLOAT:
      return(number-data.float_value);
      break;
    default:
      throw plError(2,"float - plData");
    }
}
//=============================================================================
inline plData operator-(double number, const plData& data) 
{
  switch (data.data_type)
    {
    case plData::kplINTEGER:
      return(number-data.int_value);
      break;
    case plData::kplFLOAT:
      return(number-data.float_value);
      break;
    default:
      throw plError(2,"double - plData");
    }
}

//=============================================================================
inline plData operator-(long double number, const plData& data) 
{
  switch (data.data_type)
    {
    case plData::kplINTEGER:
      return(number-data.int_value);
      break;
    case plData::kplFLOAT:
      return(number-data.float_value);
      break;
    default:
      throw plError(2,"long double - plData");
    }
}
#endif  //ravi_interface

//=============================================================================
// following functions defined to work under ravi

inline plData toData(const float& v) 
{
  return(v);
}


//=============================================================================
inline plData toData(const int& v) 
{
  return(v); 
}

#endif

---