def test_quantizationtools_MeasurewiseQSchema___getitem___02():
item_a = quantizationtools.MeasurewiseQSchemaItem(
search_tree=abjad.quantizationtools.UnweightedSearchTree({2: None}))
item_b = quantizationtools.MeasurewiseQSchemaItem(tempo=((1, 4), 76))
item_c = quantizationtools.MeasurewiseQSchemaItem(time_signature=(3, 4))
item_d = quantizationtools.MeasurewiseQSchemaItem(
search_tree=abjad.quantizationtools.UnweightedSearchTree({5: None}),
use_full_measure=True)
schema = quantizationtools.MeasurewiseQSchema(
{
2: item_a,
4: item_b,
7: item_c,
8: item_d
},
search_tree=abjad.quantizationtools.UnweightedSearchTree({3: None}),
tempo=((1, 8), 58),
time_signature=(5, 8),
use_full_measure=False,
)
assert schema[0] == schema[1] == {
'search_tree': quantizationtools.UnweightedSearchTree({3: None}),
'tempo': abjad.MetronomeMark((1, 8), 58),
'time_signature': abjad.TimeSignature((5, 8)),
'use_full_measure': False,
}
assert schema[2] == schema[3] == {
'search_tree': quantizationtools.UnweightedSearchTree({2: None}),
'tempo': abjad.MetronomeMark((1, 8), 58),
'time_signature': abjad.TimeSignature((5, 8)),
'use_full_measure': False,
}
assert schema[4] == schema[5] == schema[6] == {
'search_tree': quantizationtools.UnweightedSearchTree({2: None}),
'tempo': abjad.MetronomeMark((1, 4), 76),
'time_signature': abjad.TimeSignature((5, 8)),
'use_full_measure': False,
}
assert schema[7] == {
'search_tree': quantizationtools.UnweightedSearchTree({2: None}),
'tempo': abjad.MetronomeMark((1, 4), 76),
'time_signature': abjad.TimeSignature((3, 4)),
'use_full_measure': False,
}
assert schema[8] == schema[9] == schema[1000] == {
'search_tree': quantizationtools.UnweightedSearchTree({5: None}),
'tempo': abjad.MetronomeMark((1, 4), 76),
'time_signature': abjad.TimeSignature((3, 4)),
'use_full_measure': True,
}
def test_quantizationtools_UnweightedSearchTree___call___01():
definition = {2: {2: {2: None}, 3: None}, 5: None}
search_tree = quantizationtools.UnweightedSearchTree(definition)
q_grid = quantizationtools.QGrid()
a = quantizationtools.QEventProxy(
quantizationtools.SilentQEvent(0, ['A'], index=1), 0, 1)
b = quantizationtools.QEventProxy(
quantizationtools.SilentQEvent((1, 5), ['B'], index=2), 0, 1)
c = quantizationtools.QEventProxy(
quantizationtools.SilentQEvent((1, 4), ['C'], index=3), 0, 1)
d = quantizationtools.QEventProxy(
quantizationtools.SilentQEvent((1, 3), ['D'], index=4), 0, 1)
e = quantizationtools.QEventProxy(
quantizationtools.SilentQEvent((2, 5), ['E'], index=5), 0, 1)
f = quantizationtools.QEventProxy(
quantizationtools.SilentQEvent((1, 2), ['F'], index=6), 0, 1)
g = quantizationtools.QEventProxy(
quantizationtools.SilentQEvent((3, 5), ['G'], index=7), 0, 1)
h = quantizationtools.QEventProxy(
quantizationtools.SilentQEvent((2, 3), ['H'], index=8), 0, 1)
i = quantizationtools.QEventProxy(
quantizationtools.SilentQEvent((3, 4), ['I'], index=9), 0, 1)
j = quantizationtools.QEventProxy(
quantizationtools.SilentQEvent((4, 5), ['J'], index=10), 0, 1)
k = quantizationtools.QEventProxy(
quantizationtools.SilentQEvent(1, ['K'], index=11), 0, 1)
q_grid.fit_q_events([a, b, c, d, e, f, g, h, i, j, k])
q_grids = search_tree(q_grid)
assert q_grids[0].root_node.rtm_format == '(1 (1 1))'
assert q_grids[1].root_node.rtm_format == '(1 (1 1 1 1 1))'
def __init__(
self,
beatspan=None,
offset_in_ms=None,
search_tree=None,
tempo=None,
):
from abjad.tools import quantizationtools
beatspan = beatspan or durationtools.Duration(0)
beatspan = durationtools.Duration(beatspan)
offset_in_ms = offset_in_ms or durationtools.Duration(0)
offset_in_ms = durationtools.Offset(offset_in_ms)
if search_tree is None:
search_tree = quantizationtools.UnweightedSearchTree()
assert isinstance(search_tree, quantizationtools.SearchTree)
tempo = tempo or indicatortools.Tempo(durationtools.Duration(1, 4), 60)
#tempo = indicatortools.Tempo(tempo)
if isinstance(tempo, tuple):
tempo = indicatortools.Tempo(*tempo)
assert not tempo.is_imprecise
q_events = []
q_grids = []
self._beatspan = beatspan
self._distances = {}
self._offset_in_ms = offset_in_ms
self._q_events = q_events
self._q_grid = None
self._q_grids = q_grids
self._search_tree = search_tree
self._tempo = tempo
def test_quantizationtools_MeasurewiseQSchema___init___01():
item_a = quantizationtools.MeasurewiseQSchemaItem(
search_tree=abjad.quantizationtools.UnweightedSearchTree({2: None}))
item_b = quantizationtools.MeasurewiseQSchemaItem(tempo=((1, 4), 76))
item_c = quantizationtools.MeasurewiseQSchemaItem(time_signature=(3, 4))
item_d = quantizationtools.MeasurewiseQSchemaItem(use_full_measure=True)
schema = quantizationtools.MeasurewiseQSchema(
{
2: item_a,
4: item_b,
7: item_c,
8: item_d
},
search_tree=abjad.quantizationtools.UnweightedSearchTree({3: None}),
tempo=((1, 8), 58),
time_signature=(5, 8),
use_full_measure=False,
)
assert len(schema.items) == 4
assert schema.search_tree == quantizationtools.UnweightedSearchTree(
{3: None})
assert schema.tempo == abjad.MetronomeMark((1, 8), 58)
assert schema.time_signature == abjad.TimeSignature((5, 8))
assert schema.use_full_measure == False
def __init__(
self,
job_id=1,
search_tree=None,
q_event_proxies=None,
q_grids=None,
):
from abjad.tools import quantizationtools
search_tree = search_tree or \
quantizationtools.UnweightedSearchTree()
q_event_proxies = q_event_proxies or []
assert isinstance(search_tree, quantizationtools.SearchTree)
assert all(
isinstance(x, quantizationtools.QEventProxy)
for x in q_event_proxies
)
self._job_id = job_id
self._search_tree = search_tree
self._q_event_proxies = tuple(q_event_proxies)
if q_grids is None:
self._q_grids = ()
else:
assert all(
isinstance(x, quantizationtools.QGrid)
for x in q_grids
)
self._q_grids = tuple(q_grids)
def test_quantizationtools_BeatwiseQSchema___init___02():
schema = abjad.quantizationtools.BeatwiseQSchema()
assert len(schema.items) == 0
assert schema.beatspan == abjad.Duration(1, 4)
assert schema.search_tree == quantizationtools.UnweightedSearchTree()
assert schema.tempo == abjad.MetronomeMark((1, 4), 60)
def __init__(
self,
offset_in_ms=None,
search_tree=None,
time_signature=None,
tempo=None,
use_full_measure=False,
):
from abjad.tools import quantizationtools
offset_in_ms = offset_in_ms or 0
offset_in_ms = durationtools.Offset(offset_in_ms)
if search_tree is None:
search_tree = quantizationtools.UnweightedSearchTree()
assert isinstance(search_tree, quantizationtools.SearchTree)
tempo = tempo or indicatortools.Tempo((1, 4), 60)
#tempo = indicatortools.Tempo(tempo)
if isinstance(tempo, tuple):
tempo = indicatortools.Tempo(*tempo)
assert not tempo.is_imprecise
time_signature = time_signature or (4, 4)
time_signature = indicatortools.TimeSignature(time_signature)
use_full_measure = bool(use_full_measure)
beats = []
if use_full_measure:
beatspan = time_signature.duration
beat = quantizationtools.QTargetBeat(
beatspan=beatspan,
offset_in_ms=offset_in_ms,
search_tree=search_tree,
tempo=tempo
)
beats.append(beat)
else:
beatspan = durationtools.Duration(1, time_signature.denominator)
current_offset_in_ms = offset_in_ms
beatspan_duration_in_ms = \
tempo.duration_to_milliseconds(beatspan)
for i in range(time_signature.numerator):
beat = quantizationtools.QTargetBeat(
beatspan=beatspan,
offset_in_ms=current_offset_in_ms,
search_tree=search_tree,
tempo=tempo
)
beats.append(beat)
current_offset_in_ms += beatspan_duration_in_ms
self._beats = tuple(beats)
self._offset_in_ms = offset_in_ms
self._search_tree = search_tree
self._tempo = tempo
self._time_signature = time_signature
self._use_full_measure = use_full_measure
def test_quantizationtools_BeatwiseQSchema___getitem___01():
schema = abjad.quantizationtools.BeatwiseQSchema()
assert schema[0] == schema[1] == schema[2] == {
'beatspan': abjad.Duration(1, 4),
'search_tree': quantizationtools.UnweightedSearchTree(),
'tempo': abjad.MetronomeMark((1, 4), 60),
}
def test_quantizationtools_MeasurewiseQSchema___init___02():
schema = quantizationtools.MeasurewiseQSchema()
assert len(schema.items) == 0
assert schema.search_tree == quantizationtools.UnweightedSearchTree()
assert schema.tempo == abjad.MetronomeMark((1, 4), 60)
assert schema.time_signature == abjad.TimeSignature((4, 4))
assert schema.use_full_measure == False
def test_quantizationtools_MeasurewiseQSchema___getitem___01():
schema = quantizationtools.MeasurewiseQSchema()
assert schema[0] == schema[1] == schema[2] == {
'search_tree': quantizationtools.UnweightedSearchTree(),
'tempo': abjad.MetronomeMark((1, 4), 60),
'time_signature': abjad.TimeSignature((4, 4)),
'use_full_measure': False,
}
def __init__(self, *args, **kwargs):
from abjad.tools import quantizationtools
self._beatspan = durationtools.Duration(kwargs.get('beatspan', (1, 4)))
search_tree = kwargs.get('search_tree',
quantizationtools.UnweightedSearchTree())
assert isinstance(search_tree, quantizationtools.SearchTree)
self._search_tree = search_tree
tempo = kwargs.get('tempo', ((1, 4), 60))
if isinstance(tempo, tuple):
tempo = indicatortools.Tempo(*tempo)
self._tempo = tempo
QSchema.__init__(self, *args, **kwargs)
def __init__(self, *arguments, **keywords):
import abjad
from abjad.tools import quantizationtools
self._beatspan = abjad.Duration(keywords.get('beatspan', (1, 4)))
search_tree = keywords.get('search_tree',
quantizationtools.UnweightedSearchTree())
assert isinstance(search_tree, quantizationtools.SearchTree)
self._search_tree = search_tree
tempo = keywords.get('tempo', ((1, 4), 60))
if isinstance(tempo, tuple):
tempo = indicatortools.MetronomeMark(*tempo)
self._tempo = tempo
QSchema.__init__(self, *arguments, **keywords)
def test_quantizationtools_UnweightedSearchTree__find_leaf_subdivisions_01():
definition = {2: {2: {2: None}, 3: None}, 5: None}
search_tree = quantizationtools.UnweightedSearchTree(definition)
assert search_tree._find_leaf_subdivisions(
(1, (1, 2))) == ((1, 1), (1, 1, 1))
assert search_tree._find_leaf_subdivisions(
(1, (1, 2), (1, 2))) == ((1, 1), )
assert search_tree._find_leaf_subdivisions(
(1, (1, 2), (1, 2), (1, 2))) == ()
assert search_tree._find_leaf_subdivisions((1, (1, 2), (1, 3))) == ()
assert search_tree._find_leaf_subdivisions((1, (1, 5))) == ()
def test_quantizationtools_BeatwiseQSchema___getitem___02():
item_a = abjad.quantizationtools.BeatwiseQSchemaItem(
search_tree=abjad.quantizationtools.UnweightedSearchTree({2: None}))
item_b = abjad.quantizationtools.BeatwiseQSchemaItem(tempo=((1, 4), 76))
item_c = abjad.quantizationtools.BeatwiseQSchemaItem(beatspan=(1, 8),
search_tree=abjad.quantizationtools.UnweightedSearchTree({5: None}))
schema = abjad.quantizationtools.BeatwiseQSchema(
{2: item_a, 4: item_b, 7: item_c},
beatspan=abjad.Duration(1, 32),
search_tree=abjad.quantizationtools.UnweightedSearchTree({3: None}),
tempo=abjad.MetronomeMark((1, 16), 36)
)
assert schema[0] == schema[1] == {
'beatspan': abjad.Duration(1, 32),
'search_tree': quantizationtools.UnweightedSearchTree({3: None}),
'tempo': abjad.MetronomeMark((1, 16), 36),
}
assert schema[2] == schema[3] == {
'beatspan': abjad.Duration(1, 32),
'search_tree': quantizationtools.UnweightedSearchTree({2: None}),
'tempo': abjad.MetronomeMark((1, 16), 36),
}
assert schema[4] == schema[5] == schema[6] == {
'beatspan': abjad.Duration(1, 32),
'search_tree': quantizationtools.UnweightedSearchTree({2: None}),
'tempo': abjad.MetronomeMark((1, 4), 76),
}
assert schema[7] == schema[8] == schema[1000] == {
'beatspan': abjad.Duration(1, 8),
'search_tree': quantizationtools.UnweightedSearchTree({5: None}),
'tempo': abjad.MetronomeMark((1, 4), 76),
}
def __init__(self, *arguments, **keywords):
from abjad.tools import quantizationtools
search_tree = keywords.get('search_tree',
quantizationtools.UnweightedSearchTree())
assert isinstance(search_tree, quantizationtools.SearchTree)
self._search_tree = search_tree
tempo = keywords.get('tempo', ((1, 4), 60))
if isinstance(tempo, tuple):
tempo = indicatortools.MetronomeMark(*tempo)
self._tempo = tempo
self._time_signature = indicatortools.TimeSignature(
keywords.get('time_signature', (4, 4)))
self._use_full_measure = bool(keywords.get('use_full_measure'))
QSchema.__init__(self, *arguments, **keywords)
def test_quantizationtools_ParallelJobHandler___call___02():
job_id = 1
definition = {2: {2: {2: None}, 3: None}, 5: None}
search_tree = quantizationtools.UnweightedSearchTree(definition)
q_event_proxies = [
quantizationtools.QEventProxy(
quantizationtools.SilentQEvent(0, ['A'], index=1), 0, 1),
quantizationtools.QEventProxy(
quantizationtools.SilentQEvent((1, 5), ['B'], index=2), 0, 1),
quantizationtools.QEventProxy(
quantizationtools.SilentQEvent((1, 4), ['C'], index=3), 0, 1),
quantizationtools.QEventProxy(
quantizationtools.SilentQEvent((1, 3), ['D'], index=4), 0, 1),
quantizationtools.QEventProxy(
quantizationtools.SilentQEvent((2, 5), ['E'], index=5), 0, 1),
quantizationtools.QEventProxy(
quantizationtools.SilentQEvent((1, 2), ['F'], index=6), 0, 1),
quantizationtools.QEventProxy(
quantizationtools.SilentQEvent((3, 5), ['G'], index=7), 0, 1),
quantizationtools.QEventProxy(
quantizationtools.SilentQEvent((2, 3), ['H'], index=8), 0, 1),
quantizationtools.QEventProxy(
quantizationtools.SilentQEvent((3, 4), ['I'], index=9), 0, 1),
quantizationtools.QEventProxy(
quantizationtools.SilentQEvent((4, 5), ['J'], index=10), 0, 1),
quantizationtools.QEventProxy(
quantizationtools.SilentQEvent(1, ['K'], index=11), 0, 1)
]
job_a = quantizationtools.QuantizationJob(job_id, search_tree,
q_event_proxies)
job_b = quantizationtools.QuantizationJob(job_id, search_tree,
q_event_proxies)
assert job_a == job_b
a_jobs = quantizationtools.SerialJobHandler()([job_a])
b_jobs = quantizationtools.ParallelJobHandler()([job_b])
assert len(a_jobs) == len(b_jobs)
a_rtms = sorted(
[q_grid.root_node.rtm_format for q_grid in a_jobs[0].q_grids])
b_rtms = sorted(
[q_grid.root_node.rtm_format for q_grid in b_jobs[0].q_grids])
assert a_rtms == b_rtms
assert sorted(a_jobs[0].q_grids, key=lambda x: x.root_node.rtm_format) == \
sorted(b_jobs[0].q_grids, key=lambda x: x.root_node.rtm_format)
def test_quantizationtools_QuantizationJob___call___01():
job_id = 1
definition = {2: {2: {2: None}, 3: None}, 5: None}
search_tree = quantizationtools.UnweightedSearchTree(definition)
q_event_proxies = [
quantizationtools.QEventProxy(
quantizationtools.SilentQEvent(0, ['A'], index=1), 0, 1),
quantizationtools.QEventProxy(
quantizationtools.SilentQEvent((1, 5), ['B'], index=2), 0, 1),
quantizationtools.QEventProxy(
quantizationtools.SilentQEvent((1, 4), ['C'], index=3), 0, 1),
quantizationtools.QEventProxy(
quantizationtools.SilentQEvent((1, 3), ['D'], index=4), 0, 1),
quantizationtools.QEventProxy(
quantizationtools.SilentQEvent((2, 5), ['E'], index=5), 0, 1),
quantizationtools.QEventProxy(
quantizationtools.SilentQEvent((1, 2), ['F'], index=6), 0, 1),
quantizationtools.QEventProxy(
quantizationtools.SilentQEvent((3, 5), ['G'], index=7), 0, 1),
quantizationtools.QEventProxy(
quantizationtools.SilentQEvent((2, 3), ['H'], index=8), 0, 1),
quantizationtools.QEventProxy(
quantizationtools.SilentQEvent((3, 4), ['I'], index=9), 0, 1),
quantizationtools.QEventProxy(
quantizationtools.SilentQEvent((4, 5), ['J'], index=10), 0, 1),
quantizationtools.QEventProxy(
quantizationtools.SilentQEvent(1, ['K'], index=11), 0, 1)
]
job = quantizationtools.QuantizationJob(job_id, search_tree,
q_event_proxies)
job()
assert len(job.q_grids) == 10
rtm_formats = [q_grid.root_node.rtm_format for q_grid in job.q_grids]
rtm_formats.sort(reverse=True)
assert rtm_formats == [
'1', '(1 (1 1))', '(1 (1 1 1 1 1))', '(1 ((1 (1 1)) (1 (1 1))))',
'(1 ((1 (1 1)) (1 (1 1 1))))', '(1 ((1 (1 1 1)) (1 (1 1))))',
'(1 ((1 (1 1 1)) (1 (1 1 1))))',
'(1 ((1 (1 1 1)) (1 ((1 (1 1)) (1 (1 1))))))',
'(1 ((1 ((1 (1 1)) (1 (1 1)))) (1 (1 1 1))))',
'(1 ((1 ((1 (1 1)) (1 (1 1)))) (1 ((1 (1 1)) (1 (1 1))))))'
], rtm_formats
def test_quantizationtools_QuantizationJob_pickle_01():
job_id = 1
definition = {
2: {
2: {
2: None
},
3: None
},
5: None
}
search_tree = quantizationtools.UnweightedSearchTree(definition)
q_event_proxies = [
quantizationtools.QEventProxy(quantizationtools.SilentQEvent(0, ['A'], index=1), 0, 1),
quantizationtools.QEventProxy(quantizationtools.SilentQEvent((1, 5), ['B'], index=2), 0, 1),
quantizationtools.QEventProxy(quantizationtools.SilentQEvent((1, 4), ['C'], index=3), 0, 1),
quantizationtools.QEventProxy(quantizationtools.SilentQEvent((1, 3), ['D'], index=4), 0, 1),
quantizationtools.QEventProxy(quantizationtools.SilentQEvent((2, 5), ['E'], index=5), 0, 1),
quantizationtools.QEventProxy(quantizationtools.SilentQEvent((1, 2), ['F'], index=6), 0, 1),
quantizationtools.QEventProxy(quantizationtools.SilentQEvent((3, 5), ['G'], index=7), 0, 1),
quantizationtools.QEventProxy(quantizationtools.SilentQEvent((2, 3), ['H'], index=8), 0, 1),
quantizationtools.QEventProxy(quantizationtools.SilentQEvent((3, 4), ['I'], index=9), 0, 1),
quantizationtools.QEventProxy(quantizationtools.SilentQEvent((4, 5), ['J'], index=10), 0, 1),
quantizationtools.QEventProxy(quantizationtools.SilentQEvent(1, ['K'], index=11), 0, 1)
]
job = quantizationtools.QuantizationJob(job_id, search_tree, q_event_proxies)
pickled = pickle.loads(pickle.dumps(job))
assert pickled is not job
assert format(pickled) == format(job), \
systemtools.TestManager.diff(pickled, job, 'Diff:')
job()
pickled = pickle.loads(pickle.dumps(job))
assert pickled is not job
assert format(pickled) == format(job), \
systemtools.TestManager.diff(pickled, job, 'Diff:')
def test_quantizationtools_BeatwiseQSchema___init___01():
item_a = abjad.quantizationtools.BeatwiseQSchemaItem(
search_tree=abjad.quantizationtools.UnweightedSearchTree({2: None}))
item_b = abjad.quantizationtools.BeatwiseQSchemaItem(tempo=((1, 4), 76))
item_c = abjad.quantizationtools.BeatwiseQSchemaItem(beatspan=(1, 8))
schema = abjad.quantizationtools.BeatwiseQSchema(
{
2: item_a,
4: item_b,
7: item_c
},
beatspan=abjad.Duration(1, 32),
search_tree=abjad.quantizationtools.UnweightedSearchTree({3: None}),
tempo=abjad.MetronomeMark((1, 16), 32))
assert len(schema.items) == 3
assert schema.beatspan == abjad.Duration(1, 32)
assert schema.search_tree == quantizationtools.UnweightedSearchTree(
{3: None})
assert schema.tempo == abjad.MetronomeMark((1, 16), 32)
def test_quantizationtools_QuantizationJob___init___01():
job_id = 1
definition = {2: {2: {2: None}, 3: None}, 5: None}
search_tree = quantizationtools.UnweightedSearchTree(definition)
q_event_proxies = [
quantizationtools.QEventProxy(
quantizationtools.SilentQEvent(0, ['A'], index=1), 0, 1),
quantizationtools.QEventProxy(
quantizationtools.SilentQEvent((1, 5), ['B'], index=2), 0, 1),
quantizationtools.QEventProxy(
quantizationtools.SilentQEvent((1, 4), ['C'], index=3), 0, 1),
quantizationtools.QEventProxy(
quantizationtools.SilentQEvent((1, 3), ['D'], index=4), 0, 1),
quantizationtools.QEventProxy(
quantizationtools.SilentQEvent((2, 5), ['E'], index=5), 0, 1),
quantizationtools.QEventProxy(
quantizationtools.SilentQEvent((1, 2), ['F'], index=6), 0, 1),
quantizationtools.QEventProxy(
quantizationtools.SilentQEvent((3, 5), ['G'], index=7), 0, 1),
quantizationtools.QEventProxy(
quantizationtools.SilentQEvent((2, 3), ['H'], index=8), 0, 1),
quantizationtools.QEventProxy(
quantizationtools.SilentQEvent((3, 4), ['I'], index=9), 0, 1),
quantizationtools.QEventProxy(
quantizationtools.SilentQEvent((4, 5), ['J'], index=10), 0, 1),
quantizationtools.QEventProxy(
quantizationtools.SilentQEvent(1, ['K'], index=11), 0, 1)
]
job = quantizationtools.QuantizationJob(job_id, search_tree,
q_event_proxies)
assert job.job_id == job_id
assert job.search_tree == search_tree
assert job.q_event_proxies == tuple(q_event_proxies)
def test_quantizationtools_UnweightedSearchTree__find_divisible_leaf_indices_and_subdivisions_01(
):
definition = {2: {2: {2: None}, 3: None}, 5: None}
search_tree = quantizationtools.UnweightedSearchTree(definition)
q_grid = quantizationtools.QGrid()
a = quantizationtools.QEventProxy(quantizationtools.SilentQEvent(0, ['A']),
0, 1)
b = quantizationtools.QEventProxy(
quantizationtools.SilentQEvent((1, 5), ['B']), 0, 1)
c = quantizationtools.QEventProxy(
quantizationtools.SilentQEvent((1, 4), ['C']), 0, 1)
d = quantizationtools.QEventProxy(
quantizationtools.SilentQEvent((1, 3), ['D']), 0, 1)
e = quantizationtools.QEventProxy(
quantizationtools.SilentQEvent((2, 5), ['E']), 0, 1)
f = quantizationtools.QEventProxy(
quantizationtools.SilentQEvent((1, 2), ['F']), 0, 1)
g = quantizationtools.QEventProxy(
quantizationtools.SilentQEvent((3, 5), ['G']), 0, 1)
h = quantizationtools.QEventProxy(
quantizationtools.SilentQEvent((2, 3), ['H']), 0, 1)
i = quantizationtools.QEventProxy(
quantizationtools.SilentQEvent((3, 4), ['I']), 0, 1)
j = quantizationtools.QEventProxy(
quantizationtools.SilentQEvent((4, 5), ['J']), 0, 1)
k = quantizationtools.QEventProxy(quantizationtools.SilentQEvent(1, ['K']),
0, 1)
q_grid.fit_q_events([a, b, c, d, e, f, g, h, i, j, k])
indices, subdivisions = search_tree._find_divisible_leaf_indices_and_subdivisions(
q_grid)
assert indices == [0]
assert subdivisions == [((1, 1), (1, 1, 1, 1, 1))]
def test_quantizationtools_UnweightedSearchTree___init___01():
search_tree = quantizationtools.UnweightedSearchTree()
assert search_tree.definition == search_tree.default_definition
def test_quantizationtools_UnweightedSearchTree___init___02():
definition = {2: None, 3: {2: None}}
search_tree = quantizationtools.UnweightedSearchTree(definition)
assert search_tree.definition == definition
