def test_basic(self):
"""
Tests a bunch of different constellations by using generic
modulation, a channel, and generic demodulation. The generic
demodulation uses constellation_receiver which is what
we're really trying to test.
"""
rndm = random.Random()
rndm.seed(SEED)
# Assumes not more than 64 points in a constellation
# Generates some random input data to use.
self.src_data = tuple(
[rndm.randint(0, 1) for i in range(0, self.max_data_length)])
# Generates some random indices to use for comparing input and
# output data (a full comparison is too slow in python).
self.indices = alignment.random_sample(self.max_data_length,
self.max_num_samples, SEED)
requirements = (
(EASY_REQ_CORRECT,
tested_constellations(easy=True, medium=False, difficult=False)),
(MEDIUM_REQ_CORRECT,
tested_constellations(easy=False, medium=True, difficult=False)),
)
for req_correct, tcs in requirements:
for constellation, differential in tcs:
# The constellation_receiver doesn't work for constellations
# of multple dimensions (i.e. multiple complex numbers to a
# single symbol).
# That is not implemented since the receiver has no way of
# knowing where the beginning of a symbol is.
# It also doesn't work for non-differential modulation.
if constellation.dimensionality() != 1 or not differential:
continue
data_length = DATA_LENGTH * constellation.bits_per_symbol()
tb = rec_test_tb(constellation,
differential,
src_data=self.src_data[:data_length])
tb.run()
data = tb.dst.data()
d1 = tb.src_data[:int(len(tb.src_data) * self.ignore_fraction)]
d2 = data[:int(len(data) * self.ignore_fraction)]
correct, overlap, offset, indices = alignment.align_sequences(
d1, d2, indices=self.indices)
if correct <= req_correct:
print(
"Constellation is {0}. Differential is {1}. Required correct is {2}. Correct is {3}. FAIL."
.format(constellation, differential, req_correct,
correct))
self.assertTrue(correct > req_correct)
def test_basic(self):
"""
Tests a bunch of different constellations by using generic
modulation, a channel, and generic demodulation. The generic
demodulation uses constellation_receiver which is what
we're really trying to test.
"""
rndm = random.Random()
rndm.seed(SEED)
# Assumes not more than 64 points in a constellation
# Generates some random input data to use.
self.src_data = tuple(
[rndm.randint(0,1) for i in range(0, self.max_data_length)])
# Generates some random indices to use for comparing input and
# output data (a full comparison is too slow in python).
self.indices = alignment.random_sample(
self.max_data_length, self.max_num_samples, SEED)
requirements = (
(EASY_REQ_CORRECT, tested_constellations(easy=True, medium=False, difficult=False)),
(MEDIUM_REQ_CORRECT, tested_constellations(easy=False, medium=True, difficult=False)),
)
for req_correct, tcs in requirements:
for constellation, differential in tcs:
# The constellation_receiver doesn't work for constellations
# of multple dimensions (i.e. multiple complex numbers to a
# single symbol).
# That is not implemented since the receiver has no way of
# knowing where the beginning of a symbol is.
# It also doesn't work for non-differential modulation.
if constellation.dimensionality() != 1 or not differential:
continue
data_length = DATA_LENGTH * constellation.bits_per_symbol()
tb = rec_test_tb(constellation, differential,
src_data=self.src_data[:data_length])
tb.run()
data = tb.dst.data()
d1 = tb.src_data[:int(len(tb.src_data)*self.ignore_fraction)]
d2 = data[:int(len(data)*self.ignore_fraction)]
correct, overlap, offset, indices = alignment.align_sequences(
d1, d2, indices=self.indices)
if correct <= req_correct:
print("Constellation is {0}. Differential is {1}. Required correct is {2}. Correct is {3}. FAIL.".
format(constellation, differential, req_correct, correct))
self.assertTrue(correct > req_correct)
def test_basic(self):
"""
Tests a bunch of different constellations by using generic
modulation, a channel, and generic demodulation. The generic
demodulation uses constellation_receiver which is what
we're really trying to test.
"""
# Assumes not more than 64 points in a constellation
# Generates some random input data to use.
self.src_data = tuple(
[random.randint(0, 1) for i in range(0, self.max_data_length)])
# Generates some random indices to use for comparing input and
# output data (a full comparison is too slow in python).
self.indices = alignment.random_sample(self.max_data_length,
self.max_num_samples, self.seed)
for constellation, differential in tested_constellations():
# The constellation_receiver doesn't work for constellations
# of multple dimensions (i.e. multiple complex numbers to a
# single symbol).
# That is not implemented since the receiver has no way of
# knowing where the beginning of a symbol is.
# It also doesn't work for non-differential modulation.
if constellation.dimensionality() != 1 or not differential:
continue
data_length = DATA_LENGTH * constellation.bits_per_symbol()
tb = rec_test_tb(constellation,
differential,
src_data=self.src_data[:data_length])
tb.run()
data = tb.dst.data()
d1 = tb.src_data[:int(len(tb.src_data) * self.ignore_fraction)]
d2 = data[:int(len(data) * self.ignore_fraction)]
correct, overlap, offset, indices = alignment.align_sequences(
d1, d2, indices=self.indices)
self.assertTrue(correct > REQ_CORRECT)
def test_basic(self):
"""
Tests a bunch of different constellations by using generic
modulation, a channel, and generic demodulation. The generic
demodulation uses constellation_receiver which is what
we're really trying to test.
"""
# Assumes not more than 64 points in a constellation
# Generates some random input data to use.
self.src_data = tuple(
[random.randint(0,1) for i in range(0, self.max_data_length)])
# Generates some random indices to use for comparing input and
# output data (a full comparison is too slow in python).
self.indices = alignment.random_sample(
self.max_data_length, self.max_num_samples, self.seed)
for constellation, differential in tested_constellations():
# The constellation_receiver doesn't work for constellations
# of multple dimensions (i.e. multiple complex numbers to a
# single symbol).
# That is not implemented since the receiver has no way of
# knowing where the beginning of a symbol is.
# It also doesn't work for non-differential modulation.
if constellation.dimensionality() != 1 or not differential:
continue
data_length = DATA_LENGTH * constellation.bits_per_symbol()
tb = rec_test_tb(constellation, differential,
src_data=self.src_data[:data_length])
tb.run()
data = tb.dst.data()
d1 = tb.src_data[:int(len(tb.src_data)*self.ignore_fraction)]
d2 = data[:int(len(data)*self.ignore_fraction)]
correct, overlap, offset, indices = alignment.align_sequences(
d1, d2, indices=self.indices)
self.assertTrue(correct > REQ_CORRECT)
