卷积交织/解交织C++程序

交织基数为M,交织深度为I的卷积交织/解交织程序，延时为I*(I-1)*M.

 #include <iostream>

 #include <vector>

 #include <list>

 #include <cstdint>

 using namespace std;

 vector<uint8_t> interleaving(vector<uint8_t> &sym_din, size_t M, size_t I)

 {

     list<uint8_t> sym_fifo[I];

     vector<uint8_t> sym_itlv;

     // Initialize Data FiFo

     for(size_t i = ; i < I; ++i) {

         for(size_t j = ; j < M*i; ++j)

             sym_fifo[i].push_back(uint8_t());

     }

     // Interleaving

     for(size_t i = ; i < sym_din.size(); ++i) {

         sym_fifo[size_t(i%I)].push_back(sym_din[i]);

         sym_itlv.push_back(sym_fifo[i%I].front());

         sym_fifo[i%I].pop_front();

     }

     return sym_itlv;

 }

 vector<uint8_t> deinterleaving_fifo(vector<uint8_t> &sym_din, size_t M, size_t I)

 {

     list<uint8_t> sym_fifo[I];

     vector<uint8_t> sym_itlv;

     // Initialize Data FiFo

     for(size_t i = ; i < I; ++i) {

         for(size_t j = ; j < M*(I -  - i); ++j)

             sym_fifo[i].push_back(uint8_t());

     }

     // DeInterleaving

     for(size_t i = ; i < sym_din.size(); ++i) {

         sym_fifo[size_t(i%I)].push_back(sym_din[i]);

         sym_itlv.push_back(sym_fifo[i%I].front());

         sym_fifo[i%I].pop_front();

     }

     // DeInterleaving Delay Should be I*(I-1)*M

     return sym_itlv;

 }

 vector<uint8_t> deinterleaving(vector<uint8_t> &sym_din, size_t M, size_t I)

 {

     size_t branch = ;

     size_t wraddr = ;

     size_t rdaddr = (I - ) * M;

     vector<uint8_t> sym_ram(I*(I-)*M/+);

     vector<uint8_t> sym_itlv;

     // Initialize Data RAM

     for(size_t i = ; i < I*(I-)*M/ + ; ++i) {

         sym_ram[i] = uint8_t();

     }

     // DeInterleaving

     for(size_t i = ; i < sym_din.size(); ++i) {

         branch = i % I;

         sym_ram[wraddr] = sym_din[i];

         wraddr = wraddr + (I-)*M - branch * M;

         wraddr = wraddr >= (I*(I-)*M/ + ) ? wraddr - (I*(I-)*M/ + ) : wraddr;

         sym_itlv.push_back(sym_ram[rdaddr]);

         rdaddr = rdaddr + (I-)*M - ((branch + ) % I) * M;

         rdaddr = rdaddr >= (I*(I-)*M/ + ) ? rdaddr - (I*(I-)*M/ + ) : rdaddr;

     }

     // DeInterleaving Delay Should be I*(I-1)*M

     return sym_itlv;

 }

 int main(int argc, char **argv)

 {

     size_t deint_delay = ;

     vector<uint8_t> sym_din;

     vector<uint8_t> sym_itlv;

     vector<uint8_t> sym_deitlv;

     for(size_t i = ; i < ***; ++i)

         sym_din.push_back(i+);

     sym_itlv = interleaving(sym_din, , );

     sym_deitlv = deinterleaving(sym_itlv, , );

     cout << "Interleaving:" << endl;

     for(vector<uint8_t>::iterator itr = sym_itlv.begin(); itr != sym_itlv.end(); ++itr) {

         cout << int(*itr) << ' ' << flush;

     }

     cout << endl;

     cout << "DeInterleaving:" << endl;

     for(vector<uint8_t>::iterator itr = sym_deitlv.begin(); itr != sym_deitlv.end(); ++itr) {

         cout << int(*itr) << ' ' << flush;

         if(*itr ==  && deint_delay == )

             deint_delay = itr - sym_deitlv.begin();

     }

     cout << endl;

     cout << "Deint Delay is " << deint_delay << endl;

     return ;

 }