////////////////////////////////////////////////////////////////////////////////
// Test boost::simd::transform behavior with unary operation
////////////////////////////////////////////////////////////////////////////////
NT2_TEST_CASE_TPL( transform_unary, BOOST_SIMD_SIMD_TYPES )
{
std::vector<T> data_in(113);
for(size_t i=0; i<113; ++i)
data_in[i] = T(i);
std::vector<T> data_out1(113);
boost::simd::transform(&*data_in.begin(), &*data_in.begin()+data_in.size(), &*data_out1.begin(), plus_one());
std::vector<T> data_out2(113);
std::transform(&*data_in.begin(), &*data_in.begin()+data_in.size(), &*data_out2.begin(), plus_one());
NT2_TEST_EQUAL(data_out1, data_out2);
}
////////////////////////////////////////////////////////////////////////////////
// Test boost::simd::transform behavior with binary operation
////////////////////////////////////////////////////////////////////////////////
NT2_TEST_CASE_TPL( transform_binary, BOOST_SIMD_SIMD_TYPES )
{
std::vector<T> data_in1(113);
std::vector<T> data_in2(113);
for(size_t i=0; i<113; ++i)
{
data_in1[i] = T(i);
data_in2[i] = T(10 + i);
}
std::vector<T> data_out1(113);
boost::simd::transform(&*data_in1.begin(), &*data_in1.begin()+data_in1.size(), &*data_in2.begin(), &*data_out1.begin(), plus());
std::vector<T> data_out2(113);
std::transform(&*data_in1.begin(), &*data_in1.begin()+data_in1.size(), &*data_in2.begin(), &*data_out2.begin(), plus());
NT2_TEST_EQUAL(data_out1, data_out2);
}
int main()
{
// Seed the random number generator to produce different data every time
srand((uint32_t)time(0));
// Set the number of symbols (i.e. the generation size in RLNC
// terminology) and the size of a symbol in bytes
uint32_t max_symbols = 16;
uint32_t max_symbol_size = 1400;
//! [0]
// In the following we will make an encoder/decoder factory.
// The factories are used to build actual encoders/decoders
kodocpp::encoder_factory encoder_factory(
kodocpp::codec::full_vector,
kodocpp::field::binary8,
max_symbols,
max_symbol_size);
kodocpp::encoder encoder = encoder_factory.build();
kodocpp::decoder_factory decoder_factory(
kodocpp::codec::full_vector,
kodocpp::field::binary8,
max_symbols,
max_symbol_size);
kodocpp::decoder decoder1 = decoder_factory.build();
kodocpp::decoder decoder2 = decoder_factory.build();
//! [1]
std::vector<uint8_t> payload(encoder.payload_size());
std::vector<uint8_t> data_in(encoder.block_size());
// Just for fun - fill the data with random data
std::generate(data_in.begin(), data_in.end(), rand);
// Assign the data buffer to the encoder so that we may start
// to produce encoded symbols from it
encoder.set_const_symbols(data_in.data(), encoder.block_size());
// Create a buffer which will contain the decoded data, and we assign
// that buffer to the decoder
std::vector<uint8_t> data_out1(decoder1.block_size());
std::vector<uint8_t> data_out2(decoder2.block_size());
decoder1.set_mutable_symbols(data_out1.data(), decoder1.block_size());
decoder2.set_mutable_symbols(data_out2.data(), decoder2.block_size());
uint32_t encoded_count = 0;
uint32_t dropped_count = 0;
// We switch any systematic operations off so the encoder produces
// coded symbols from the beginning
if (encoder.is_systematic_on())
encoder.set_systematic_off();
//! [2]
while (!decoder2.is_complete())
{
// Encode a packet into the payload buffer
encoder.write_payload(payload.data());
++encoded_count;
if (rand() % 2)
{
++dropped_count;
}
else
{
// Pass that packet to the decoder1
decoder1.read_payload(payload.data());
}
// Create a recoded packet from decoder1
decoder1.write_payload(payload.data());
if (rand() % 2)
{
++dropped_count;
}
else
{
// Pass the recoded packet to decoder two
decoder2.read_payload(payload.data());
}
}
//! [3]
std::cout << "Encoded count = " << encoded_count << std::endl;
std::cout << "Dropped count = " << dropped_count << std::endl;
// Check if we properly decoded the data
if (data_in == data_out2)
{
std::cout << "Data decoded correctly" << std::endl;
}
return 0;
}
