vq.h

Go to the documentation of this file.

#ifndef VQ_H
#define VQ_H

#include <itpp/base/vec.h>
#include <itpp/base/sort.h>
#include <itpp/base/math/log_exp.h>
#include <itpp/itexports.h>

namespace itpp
{

class ITPP_EXPORT Vector_Quantizer
{
public:
  Vector_Quantizer();
  Vector_Quantizer(const char *Name);
  int encode(const vec &x);
  ivec encode(const vec &x, int num);
  vec decode(int Index) const;
  Array<vec> decode(const ivec &Index) const;
  vec Q(const vec &x);
  vec operator()(const vec &x);
  void set_codebook(const mat &CB);
  mat get_codebook() const;
  void set_codevector(int Index, const vec &indata);
  vec get_codevector(int Index) const;
  void modify_codevector(int no, double mul, const vec &add);
  int size() const;
  int dim() const;
  int nobits() const;
  void load(const char *Name);
  void save(const char *Name) const;
  double latest_distortion();
protected:
  vec CodeBook;
  int Size;
  int Dim;
  double LatestDist;
};

// INLINE FUNCTIONS

inline int Vector_Quantizer::size() const { return Size; }
inline int Vector_Quantizer::nobits() const { return levels2bits(Size); }
inline int Vector_Quantizer::dim() const { return Dim; }
inline double Vector_Quantizer::latest_distortion() { return LatestDist; }
inline vec Vector_Quantizer::decode(int Index) const { return get_codevector(Index); }
inline vec Vector_Quantizer::Q(const vec &x) { return decode(encode(x)); }
inline vec Vector_Quantizer::operator()(const vec &x) { return Q(x); }

class ITPP_EXPORT Scalar_Quantizer
{
public:
  Scalar_Quantizer();
  Scalar_Quantizer(const char *Name);
  int encode(double x) const;
  ivec encode(const vec &x) const;
  double decode(int Index) const;
  vec decode(const ivec &Index) const;
  double Q(double x) const;
  vec Q(const vec &x) const;
  double operator()(double x) const;
  vec operator()(const vec &x) const;
  void set_levels(const vec &L);
  vec get_levels() const;
  int size() const;
protected:
  vec Levels;
  double LatestDist;
};

inline int Scalar_Quantizer::size() const { return Levels.length(); }
inline double Scalar_Quantizer::decode(int Index) const { return Levels(Index); }
inline double Scalar_Quantizer::Q(double x) const { return decode(encode(x)); }
inline double Scalar_Quantizer::operator()(double x) const { return Q(x); }
inline vec Scalar_Quantizer::operator()(const vec &x)  const { return Q(x); }
inline void Scalar_Quantizer::set_levels(const vec &L) {Levels = L;sort(Levels); }
inline vec Scalar_Quantizer::get_levels() const {return Levels; }

ITPP_EXPORT int scalar_encode(double x, vec &Levels) ;
ITPP_EXPORT ivec scalar_encode(vec &x, vec &Levels);
inline double scalar_quantize(double x, vec &Levels) { return Levels(scalar_encode(x, Levels)); }
inline vec scalar_quantize(vec &x, vec &Levels) { return Levels(scalar_encode(x, Levels)); }


} // namespace itpp

#endif // #ifndef VQ_H