Method Encoder_conv

src/Module/Encoder/Conv/Encoder_conv.cpp:11–70

template<typename B>
Encoder_conv<B>::Encoder_conv(const int K, const int N, const std::vector<int>& poly)
  : Encoder<B>(K, N)
  , n_ff(0)
  , n_poly(static_cast<int>(poly.size()))
  , n_states(0)
  , poly(poly)
  , next_state_table()
  , output_table()
{
    const std::string name = "Encoder_conv";
    this->set_name(name);
    for (auto& t : this->tasks)
        t->set_replicability(true);

    if (n_poly < 2)
    {
        std::stringstream message;
        message << "'poly' must have at least 2 elements ('poly.size()' = " << n_poly << ").";
        throw spu::tools::invalid_argument(__FILE__, __LINE__, __func__, message.str());
    }

    // Determine n_ff from the maximum bit width of the polynomials
    int max_poly = 0;
    for (auto g : poly)
        if (g > max_poly) max_poly = g;

    // n_ff = floor(log2(max_poly)), i.e. the number of memory elements
    int tmp = max_poly;
    int bits = 0;
    while (tmp > 0)
    {
        bits++;
        tmp >>= 1;
    }
    // const_cast to set the const member after computation
    const_cast<int&>(this->n_ff) = bits - 1;
    const_cast<int&>(this->n_states) = 1 << this->n_ff;

    if (this->n_ff <= 0)
    {
        std::stringstream message;
        message << "'n_ff' has to be greater than 0 ('n_ff' = " << this->n_ff << ").";
        throw spu::tools::invalid_argument(__FILE__, __LINE__, __func__, message.str());
    }

    if (N != n_poly * (K + this->n_ff))
    {
        std::stringstream message;
        message << "'N' must equal 'n_poly' * ('K' + 'n_ff') ('N' = " << N << ", 'n_poly' = " << n_poly
                << ", 'K' = " << K << ", 'n_ff' = " << this->n_ff << ").";
        throw spu::tools::invalid_argument(__FILE__, __LINE__, __func__, message.str());
    }

    // Set info_bits_pos: positions of the "systematic" bit in interleaved output
    // For rate 1/n_poly, info bits are at positions [0, n_poly, 2*n_poly, ...]
    for (auto k = 0; k < this->K; k++)
        this->info_bits_pos[k] = n_poly * k;