def testMixedDurationsBeams(self):
fourFour = TimeSignature('4/4')
n = note.Note
dList = [
n(type='eighth'),
n(type='quarter'),
n(type='eighth'),
n(type='eighth'),
n(type='quarter'),
n(type='eighth')
]
beamList = fourFour.getBeams(dList)
self.assertEqual(beamList, [None] * 6)
dList = [
n(type='eighth'),
n(type='quarter'),
n(type='eighth'),
n(type='eighth'),
n(type='eighth'),
n(type='quarter')
]
beamList = fourFour.getBeams(dList)
self.assertEqual([repr(b) for b in beamList], [
'None', 'None', 'None',
'<music21.beam.Beams <music21.beam.Beam 1/start>>',
'<music21.beam.Beams <music21.beam.Beam 1/stop>>', 'None'
])
def testBeatProportionFromTimeSignature(self):
# given meter, ql, beat proportion, and beat ql
data = [
['2/4', (0, 0.5, 1, 1.5), (1, 1.5, 2, 2.5), (1, 1, 1, 1)],
['3/4', (0, 0.5, 1, 1.5), (1, 1.5, 2, 2.5), (1, 1, 1, 1)],
['4/4', (0, 0.5, 1, 1.5), (1, 1.5, 2, 2.5), (1, 1, 1, 1)],
[
'6/8', (0, 0.5, 1, 1.5, 2), (1, 4 / 3, 5 / 3, 2.0, 7 / 3),
(1.5, 1.5, 1.5, 1.5, 1.5)
],
[
'9/8', (0, 0.5, 1, 1.5, 2), (1, 4 / 3, 5 / 3, 2.0, 7 / 3),
(1.5, 1.5, 1.5, 1.5, 1.5)
],
[
'12/8', (0, 0.5, 1, 1.5, 2), (1, 4 / 3, 5 / 3, 2.0, 7 / 3),
(1.5, 1.5, 1.5, 1.5, 1.5)
],
[
'2/8+3/8', (0, 0.5, 1, 1.5), (1, 1.5, 2, 7 / 3),
(1, 1, 1.5, 1.5, 1.5)
],
]
for tsStr, src, dst, beatDur in data:
ts = TimeSignature(tsStr)
for i in range(len(src)):
ql = src[i]
self.assertAlmostEqual(ts.getBeatProportion(ql), dst[i], 4)
self.assertEqual(
ts.getBeatDuration(ql).quarterLength, beatDur[i])
def testGetBeams(self):
ts = TimeSignature('6/8')
durList = [16, 16, 16, 16, 8, 16, 16, 16, 16, 8]
notesList = [note.Note(quarterLength=4 / d) for d in durList]
beams = ts.getBeams(notesList)
match = '''[<music21.beam.Beams <music21.beam.Beam 1/start>/<music21.beam.Beam 2/start>>,
<music21.beam.Beams <music21.beam.Beam 1/continue>/<music21.beam.Beam 2/continue>>,
<music21.beam.Beams <music21.beam.Beam 1/continue>/<music21.beam.Beam 2/continue>>,
<music21.beam.Beams <music21.beam.Beam 1/continue>/<music21.beam.Beam 2/stop>>,
<music21.beam.Beams <music21.beam.Beam 1/stop>>,
<music21.beam.Beams <music21.beam.Beam 1/start>/<music21.beam.Beam 2/start>>,
<music21.beam.Beams <music21.beam.Beam 1/continue>/<music21.beam.Beam 2/continue>>,
<music21.beam.Beams <music21.beam.Beam 1/continue>/<music21.beam.Beam 2/continue>>,
<music21.beam.Beams <music21.beam.Beam 1/continue>/<music21.beam.Beam 2/stop>>,
<music21.beam.Beams <music21.beam.Beam 1/stop>>]'''
self.assertTrue(common.whitespaceEqual(str(beams), match))
def testMeterDeepcopy(self):
a = MeterSequence()
a.load('4/4', 4)
b = copy.deepcopy(a)
self.assertNotEqual(a, b)
c = TimeSignature('4/4')
d = copy.deepcopy(c)
self.assertNotEqual(c, d)
def testBasic(self):
a = stream.Stream()
for meterStrDenominator in [1, 2, 4, 8, 16, 32]:
for meterStrNumerator in [2, 3, 4, 5, 6, 7, 9, 11, 12, 13]:
ts = TimeSignature(f'{meterStrNumerator}/{meterStrDenominator}')
m = stream.Measure()
m.timeSignature = ts
a.insert(m.timeSignature.barDuration.quarterLength, m)
if self.show:
a.show()
def testMeterBeam(self):
ts = TimeSignature('6/8', 2)
b = [duration.Duration('16th')] * 12
s = stream.Stream()
s.insert(0, ts)
for x in b:
n = note.Note()
n.duration = x
s.append(n)
s.show()
def testMusicxmlDirectOut(self):
# test rendering musicxml directly from meter
from music21.musicxml import m21ToXml
ts = TimeSignature('3/8')
xmlOut = m21ToXml.GeneralObjectExporter().parse(ts).decode('utf-8')
match = '<time><beats>3</beats><beat-type>8</beat-type></time>'
xmlOut = xmlOut.replace(' ', '')
xmlOut = xmlOut.replace('\n', '')
self.assertNotEqual(xmlOut.find(match), -1)
def testCompound(self):
a = stream.Stream()
meterStrDenominator = [1, 2, 4, 8, 16, 32]
meterStrNumerator = [2, 3, 4, 5, 6, 7, 9, 11, 12, 13]
for i in range(30):
msg = []
for j in range(1, random.choice([2, 4])):
msg.append('%s/%s' % (random.choice(meterStrNumerator),
random.choice(meterStrDenominator)))
ts = TimeSignature('+'.join(msg))
m = stream.Measure()
m.timeSignature = ts
a.insert(m.timeSignature.barDuration.quarterLength, m)
a.show()
def testCompoundSameDenominator(self):
ts328 = TimeSignature('3+2/8')
beatSeq = ts328.beamSequence
self.assertEqual(str(beatSeq), '{3/8+2/8}')
def testSetDefaultAccentWeights(self):
# these tests take the level to 3. in some cases, a level of 2
# is not sufficient to normalize all denominators
pairs = [
('4/4', [1.0, 0.125, 0.25, 0.125, 0.5, 0.125, 0.25, 0.125]),
('3/4', [
1.0, 0.125, 0.25, 0.125, 0.5, 0.125, 0.25, 0.125, 0.5, 0.125,
0.25, 0.125
]),
('2/4', [1.0, 0.125, 0.25, 0.125, 0.5, 0.125, 0.25, 0.125]),
# divided at 4th 8th
('6/8', [
1.0, 0.125, 0.25, 0.125, 0.25, 0.125, 0.5, 0.125, 0.25, 0.125,
0.25, 0.125
]),
# all beats are even b/c this is un-partitioned
('5/4', [
1.0, 0.125, 0.25, 0.125, 0.5, 0.125, 0.25, 0.125, 0.5, 0.125,
0.25, 0.125, 0.5, 0.125, 0.25, 0.125, 0.5, 0.125, 0.25, 0.125
]),
('9/4', [
1.0, 0.125, 0.25, 0.125, 0.25, 0.125, 0.5, 0.125, 0.25, 0.125,
0.25, 0.125, 0.5, 0.125, 0.25, 0.125, 0.25, 0.125
]),
('18/4', [
1.0, 0.125, 0.25, 0.125, 0.25, 0.125, 0.5, 0.125, 0.25, 0.125,
0.25, 0.125, 0.5, 0.125, 0.25, 0.125, 0.25, 0.125, 0.5, 0.125,
0.25, 0.125, 0.25, 0.125, 0.5, 0.125, 0.25, 0.125, 0.25, 0.125,
0.5, 0.125, 0.25, 0.125, 0.25, 0.125
]),
('3/8', [
1.0, 0.125, 0.25, 0.125, 0.5, 0.125, 0.25, 0.125, 0.5, 0.125,
0.25, 0.125
]),
('11/8', [
1.0, 0.125, 0.25, 0.125, 0.5, 0.125, 0.25, 0.125, 0.5, 0.125,
0.25, 0.125, 0.5, 0.125, 0.25, 0.125, 0.5, 0.125, 0.25, 0.125,
0.5, 0.125, 0.25, 0.125, 0.5, 0.125, 0.25, 0.125, 0.5, 0.125,
0.25, 0.125, 0.5, 0.125, 0.25, 0.125, 0.5, 0.125, 0.25, 0.125,
0.5, 0.125, 0.25, 0.125
]),
('2/8+3/8',
[1.0, 0.125, 0.25, 0.125, 0.5, 0.125, 0.25, 0.125, 0.25, 0.125]),
('3/8+2/8+3/4', [
1.0, 0.0625, 0.125, 0.0625, 0.25, 0.0625, 0.125, 0.0625, 0.25,
0.0625, 0.125, 0.0625, 0.5, 0.0625, 0.125, 0.0625, 0.25,
0.0625, 0.125, 0.0625, 0.5, 0.03125, 0.0625, 0.03125, 0.125,
0.03125, 0.0625, 0.03125, 0.25, 0.03125, 0.0625, 0.03125,
0.125, 0.03125, 0.0625, 0.03125, 0.25, 0.03125, 0.0625,
0.03125, 0.125, 0.03125, 0.0625, 0.03125
]),
('1/2+2/16', [
1.0, 0.015625, 0.03125, 0.015625, 0.0625, 0.015625, 0.03125,
0.015625, 0.125, 0.015625, 0.03125, 0.015625, 0.0625, 0.015625,
0.03125, 0.015625, 0.25, 0.015625, 0.03125, 0.015625, 0.0625,
0.015625, 0.03125, 0.015625, 0.125, 0.015625, 0.03125,
0.015625, 0.0625, 0.015625, 0.03125, 0.015625, 0.5, 0.0625,
0.125, 0.0625, 0.25, 0.0625, 0.125, 0.0625
]),
]
for tsStr, match in pairs:
# environLocal.printDebug([tsStr])
ts1 = TimeSignature(tsStr)
ts1._setDefaultAccentWeights(3) # going to a lower level here
self.assertEqual([mt.weight for mt in ts1.accentSequence], match)
def testSingle(self):
'''Need to test direct meter creation w/o stream
'''
a = TimeSignature('3/16')
if self.show:
a.show()
def testDefaultBeatPartitions(self):
src = ['2/2', '2/4', '2/8', '6/4', '6/8', '6/16']
for tsStr in src:
ts = TimeSignature(tsStr)
self.assertEqual(len(ts.beatSequence), 2)
self.assertEqual(ts.beatCountName, 'Duple')
if ts.numerator == 2:
for ms in ts.beatSequence: # should be divided in two
self.assertEqual(len(ms), 2)
elif ts.numerator == 6:
for ms in ts.beatSequence: # should be divided in three
self.assertEqual(len(ms), 3)
src = ['3/2', '3/4', '9/4', '9/8', '9/16']
for tsStr in src:
ts = TimeSignature(tsStr)
self.assertEqual(len(ts.beatSequence), 3)
self.assertEqual(ts.beatCountName, 'Triple')
if ts.numerator == 3:
for ms in ts.beatSequence: # should be divided in two
self.assertEqual(len(ms), 2)
elif ts.numerator == 9:
for ms in ts.beatSequence: # should be divided in three
self.assertEqual(len(ms), 3)
src = ['3/8', '3/16', '3/32']
for tsStr in src:
ts = TimeSignature(tsStr)
self.assertEqual(len(ts.beatSequence), 1)
self.assertEqual(ts.beatCountName, 'Single')
for ms in ts.beatSequence: # should not be divided
self.assertIsInstance(ms, MeterTerminal)
src = ['4/2', '4/4', '4/8', '12/4', '12/8', '12/16']
for tsStr in src:
ts = TimeSignature(tsStr)
self.assertEqual(len(ts.beatSequence), 4)
self.assertEqual(ts.beatCountName, 'Quadruple')
if ts.numerator == 4:
for ms in ts.beatSequence: # should be divided in two
self.assertEqual(len(ms), 2)
elif ts.numerator == 12:
for ms in ts.beatSequence: # should be divided in three
self.assertEqual(len(ms), 3)
src = ['5/2', '5/4', '5/8', '15/4', '15/8', '15/16']
for tsStr in src:
ts = TimeSignature(tsStr)
self.assertEqual(len(ts.beatSequence), 5)
self.assertEqual(ts.beatCountName, 'Quintuple')
if ts.numerator == 5:
for ms in ts.beatSequence: # should be divided in two
self.assertEqual(len(ms), 2)
elif ts.numerator == 15:
for ms in ts.beatSequence: # should be divided in three
self.assertEqual(len(ms), 3)
src = ['18/4', '18/8', '18/16']
for tsStr in src:
ts = TimeSignature(tsStr)
self.assertEqual(len(ts.beatSequence), 6)
self.assertEqual(ts.beatCountName, 'Sextuple')
if ts.numerator == 18:
for ms in ts.beatSequence: # should be divided in three
self.assertEqual(len(ms), 3)
# odd or unusual partitions
src = ['13/4', '19/8', '17/16']
for tsStr in src:
firstPart, unused = tsStr.split('/')
ts = TimeSignature(tsStr)
# self.assertEqual(len(ts.beatSequence), 6)
self.assertEqual(ts.beatCountName,
firstPart + '-uple') # "13-uple" etc.
def test_getBeams_offset(self):
'''
Test getting Beams from a Measure that has an anacrusis that makes the
first note not beamed.
'''
m = stream.Measure()
m.repeatAppend(note.Note(type='eighth'), 5)
ts = TimeSignature('2/2')
beams = ts.getBeams(m, measureStartOffset=1.5)
self.assertIsNone(beams[0])
for b in beams[1:]:
self.assertIsNotNone(b)
match = '''[None,
<music21.beam.Beams <music21.beam.Beam 1/start>>,
<music21.beam.Beams <music21.beam.Beam 1/continue>>,
<music21.beam.Beams <music21.beam.Beam 1/continue>>,
<music21.beam.Beams <music21.beam.Beam 1/stop>>]'''
self.assertTrue(common.whitespaceEqual(str(beams), match))
m.append(note.Note(type='eighth'))
beams = ts.getBeams(m, measureStartOffset=1.0)
match = '''[<music21.beam.Beams <music21.beam.Beam 1/start>>,
<music21.beam.Beams <music21.beam.Beam 1/stop>>,
<music21.beam.Beams <music21.beam.Beam 1/start>>,
<music21.beam.Beams <music21.beam.Beam 1/continue>>,
<music21.beam.Beams <music21.beam.Beam 1/continue>>,
<music21.beam.Beams <music21.beam.Beam 1/stop>>]'''
self.assertTrue(common.whitespaceEqual(str(beams), match), str(beams))
m = stream.Measure()
m.repeatAppend(note.Note(type='eighth'), 5)
ts = TimeSignature('3/2')
beams = ts.getBeams(m, measureStartOffset=3.5)
match = '''[None,
<music21.beam.Beams <music21.beam.Beam 1/start>>,
<music21.beam.Beams <music21.beam.Beam 1/continue>>,
<music21.beam.Beams <music21.beam.Beam 1/continue>>,
<music21.beam.Beams <music21.beam.Beam 1/stop>>]'''
self.assertTrue(common.whitespaceEqual(str(beams), match))
m = stream.Measure()
m.repeatAppend(note.Note(type='eighth'), 4)
ts = TimeSignature('6/8')
beams = ts.getBeams(m, measureStartOffset=1.0)
match = '''[None,
<music21.beam.Beams <music21.beam.Beam 1/start>>,
<music21.beam.Beams <music21.beam.Beam 1/continue>>,
<music21.beam.Beams <music21.beam.Beam 1/stop>>]'''
self.assertTrue(common.whitespaceEqual(str(beams), match))
m.append(note.Note(type='eighth'))
beams = ts.getBeams(m, measureStartOffset=0.5)
match = '''[<music21.beam.Beams <music21.beam.Beam 1/start>>,
<music21.beam.Beams <music21.beam.Beam 1/stop>>,
<music21.beam.Beams <music21.beam.Beam 1/start>>,
<music21.beam.Beams <music21.beam.Beam 1/continue>>,
<music21.beam.Beams <music21.beam.Beam 1/stop>>]'''
self.assertTrue(common.whitespaceEqual(str(beams), match), str(beams))