BitTable.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2008 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
#ifndef __BitTable_h
#define __BitTable_h
 
#include "Reference.h"
 
namespace dsp {
 
  class BitTable : public Reference::Able
  {
  public:
 
    static const unsigned bits_per_byte;
 
    static const unsigned unique_bytes;
 
    enum Type
    {
      OffsetBinary,
      TwosComplement,
      SignMagnitude    // for 2-bit only
    };
 
    enum Order
    {
      MostToLeast,
      LeastToMost
    };
 
    BitTable (unsigned nbit, Type type, bool reverse_bits = false);
    
    virtual ~BitTable ();
 
 
    void set_effective_nbit (unsigned bits);
    unsigned get_effective_nbit () const { return effective_nbit; }
 
    void set_order (Order);
    Order get_order () const { return order; }
 
 
    void set_zero_is_a_threshold (bool);
    bool get_zero_is_a_threshold () const { return zero_is_a_threshold; }
 
    unsigned get_values_per_byte () const { return values_per_byte; }
 
    unsigned get_unique_values () const { return unique_values; }
 
    double get_scale () const;
 
    Type get_type () const { return type; }
 
    const float* get_values (unsigned byte = 0) const;
 
    void generate (float* table) const;
 
    virtual void generate_unique_values (float* values) const;
 
    virtual unsigned extract (unsigned byte, unsigned i) const;
 
    virtual double get_optimal_variance () const;
 
    virtual double get_nlow_threshold () const;
 
    virtual void get_nlow_lookup (char* nlow_lookup) const;
 
  protected:
 
    float* table;
 
    Type type;
 
    const unsigned nbit;
 
    unsigned zero_is_a_threshold;
 
    unsigned effective_nbit;
 
    const bool reverse_bits;
 
    Order order;
 
    const unsigned values_per_byte;
 
    const unsigned unique_values;
 
    const unsigned nbit_mask;
 
    mutable double scale;
 
    void build ();
 
    void destroy ();
  };
 
}
 
#endif // !defined(__BitTable_h)