Apply tuplet to multiple components to express durations like 5/6 or 7/3 QL

music21/duration.py

@@ -503,7 +503,9 @@ def quarterLengthToTuplet(
     return post
 
 
-def quarterConversion(qLen: OffsetQLIn) -> QuarterLengthConversion:
+def quarterConversion(
+    qLen: OffsetQLIn, *, forceSingleComponent: bool = False
+) -> QuarterLengthConversion:
     '''
     Returns a 2-element namedtuple of (components, tuplet)
 
@@ -512,8 +514,12 @@ def quarterConversion(qLen: OffsetQLIn) -> QuarterLengthConversion:
 
     Tuplet is a single :class:`~music21.duration.Tuplet` that adjusts all components.
 
-    (All quarterLengths can, technically, be notated as a single unit
-    given a complex enough tuplet, as a last resort will look up to 199 as a tuplet type).
+    All quarterLengths can, technically, be notated as a single unit
+    given a complex enough tuplet. (As a last resort will look up to 199 as a tuplet type.)
+    If this type of solution is *preferred* over a solution involving multiple tied components,
+    then pass `forceSingleComponent=True` (new in v8, and can be set directly on
+    :class:`Duration` objects via the :attr:`Duration.forceSingleComponent` attribute instead
+    of calling this function directly).
 
     >>> duration.quarterConversion(2)
     QuarterLengthConversion(components=(DurationTuple(type='half', dots=0, quarterLength=2.0),),
@@ -609,13 +615,35 @@ def quarterConversion(qLen: OffsetQLIn) -> QuarterLengthConversion:
                             tuplet=None)
 
 
-    Since tuplets now apply to the entire Duration, expect some odder tuplets for unusual
-    values that should probably be split generally...
+    Since tuplets now apply to the entire Duration, multiple small components may be needed:
+
+    Duration > 1.0 QL:
 
     >>> duration.quarterConversion(7/3)
-    QuarterLengthConversion(components=(DurationTuple(type='whole', dots=0, quarterLength=4.0),),
-        tuplet=<music21.duration.Tuplet 12/7/16th>)
+    QuarterLengthConversion(components=(DurationTuple(type='eighth', dots=0, quarterLength=0.5),
+                                        DurationTuple(type='eighth', dots=0, quarterLength=0.5),
+                                        DurationTuple(type='eighth', dots=0, quarterLength=0.5),
+                                        DurationTuple(type='eighth', dots=0, quarterLength=0.5),
+                                        DurationTuple(type='eighth', dots=0, quarterLength=0.5),
+                                        DurationTuple(type='eighth', dots=0, quarterLength=0.5),
+                                        DurationTuple(type='eighth', dots=0, quarterLength=0.5)),
+                            tuplet=<music21.duration.Tuplet 3/2/eighth>)
+
+    Duration < 1.0 QL:
 
+    >>> duration.quarterConversion(5/6)
+    QuarterLengthConversion(components=(DurationTuple(type='16th', dots=0, quarterLength=0.25),
+                                        DurationTuple(type='16th', dots=0, quarterLength=0.25),
+                                        DurationTuple(type='16th', dots=0, quarterLength=0.25),
+                                        DurationTuple(type='16th', dots=0, quarterLength=0.25),
+                                        DurationTuple(type='16th', dots=0, quarterLength=0.25)),
+                            tuplet=<music21.duration.Tuplet 3/2/16th>)
+
+    But with `forceSingleComponent=True`:
+
+    >>> duration.quarterConversion(5/6, forceSingleComponent=True)
+    QuarterLengthConversion(components=(DurationTuple(type='quarter', dots=0, quarterLength=1.0),),
+                            tuplet=<music21.duration.Tuplet 6/5/32nd>)
 
     This is a very close approximation:
 
@@ -633,6 +661,24 @@ def quarterConversion(qLen: OffsetQLIn) -> QuarterLengthConversion:
                                                       dots=0,
                                                       quarterLength=99.0),),
                             tuplet=None)
+
+    OMIT_FROM_DOCS
+
+    Another > 1.0 QL case, but over 3.0QL to catch "closest smaller type" being dotted:
+
+    >>> duration.quarterConversion(11/3)
+    QuarterLengthConversion(components=(DurationTuple(type='eighth', dots=0, quarterLength=0.5),
+                                        DurationTuple(type='eighth', dots=0, quarterLength=0.5),
+                                        DurationTuple(type='eighth', dots=0, quarterLength=0.5),
+                                        DurationTuple(type='eighth', dots=0, quarterLength=0.5),
+                                        DurationTuple(type='eighth', dots=0, quarterLength=0.5),
+                                        DurationTuple(type='eighth', dots=0, quarterLength=0.5),
+                                        DurationTuple(type='eighth', dots=0, quarterLength=0.5),
+                                        DurationTuple(type='eighth', dots=0, quarterLength=0.5),
+                                        DurationTuple(type='eighth', dots=0, quarterLength=0.5),
+                                        DurationTuple(type='eighth', dots=0, quarterLength=0.5),
+                                        DurationTuple(type='eighth', dots=0, quarterLength=0.5)),
+                            tuplet=<music21.duration.Tuplet 3/2/eighth>)
     '''
     # this is a performance-critical operation that has been highly optimized for speed
     # rather than legibility or logic.  Most commonly anticipated events appear first
@@ -673,7 +719,7 @@ def quarterConversion(qLen: OffsetQLIn) -> QuarterLengthConversion:
                                                       dots=0,
                                                       quarterLength=qLen),), None)
 
-    tupleCandidates = quarterLengthToTuplet(qLen, 1)
+    tupleCandidates = quarterLengthToTuplet(qLen, maxToReturn=1)
     if tupleCandidates:
         # assume that the first tuplet candidate, using the smallest type, is best
         return QuarterLengthConversion(
@@ -687,10 +733,40 @@ def quarterConversion(qLen: OffsetQLIn) -> QuarterLengthConversion:
     # remove the largest type out there and keep going.
 
     qLenRemainder = opFrac(qLen - typeToDuration[closestSmallerType])
+
+    # but first: one opportunity to define a tuplet if remainder can be expressed as one
+    # by expressing the largest type (components[0]) in terms of the same tuplet
+    if not forceSingleComponent and isinstance(qLenRemainder, fractions.Fraction):
+        # Allow dotted type as "largest type" if > 1.0 QL
+        if qLenRemainder >= 1 and qLenRemainder > opFrac(typeToDuration[closestSmallerType] * 0.5):
+            components = [durationTupleFromTypeDots(closestSmallerType, 1)]
+            qLenRemainder = opFrac(qLen - components[0].quarterLength)
+
+        for divisor in range(1, 4):
+            largestType = components[0]
+            solutions = quarterLengthToTuplet((qLenRemainder / divisor), maxToReturn=1)
+            if solutions:
+                tup = solutions[0]
+                if largestType.quarterLength % tup.totalTupletLength() == 0:
+                    multiples = int(largestType.quarterLength // tup.totalTupletLength())
+                    numComponentsLargestType = multiples * tup.numberNotesActual
+                    numComponentsRemainder = int(
+                        (qLenRemainder / tup.totalTupletLength())
+                        * tup.numberNotesActual
+                    )
+                    numComponentsTotal = numComponentsLargestType + numComponentsRemainder
+                    components = [tup.durationActual for i in range(0, numComponentsTotal)]
+                    return QuarterLengthConversion(tuple(components), tup)
+
+    # Is it made up of many small types?
     # cannot recursively call, because tuplets are not possible at this stage.
     # environLocal.warn(['starting remainder search for qLen:', qLen,
     #    'remainder: ', qLenRemainder, 'components: ', components])
-    for i in range(8):  # max 8 iterations.
+    if forceSingleComponent:
+        iterations = 0
+    else:
+        iterations = 8
+    for _ in range(iterations):
         # environLocal.warn(['qLenRemainder is:', qLenRemainder])
         dots, durType = dottedMatch(qLenRemainder)
         if durType is not False:  # match!
@@ -1566,6 +1642,16 @@ class Duration(prebase.ProtoM21Object, SlottedObjectMixin):
     3.5
     >>> d3.expressionIsInferred
     False
+
+    Example 4: A Duration that expresses itself using an idiosyncratic
+    tuplet rather than multiple components:
+
+    >>> d4 = duration.Duration(0.625)  # same as example 2
+    >>> d4.forceSingleComponent = True
+    >>> d4.components
+    (DurationTuple(type='quarter', dots=0, quarterLength=1.0),)
+    >>> d4.tuplets
+    (<music21.duration.Tuplet 8/5/32nd>,)
     '''
 
     # CLASS VARIABLES #
@@ -1583,6 +1669,7 @@ class Duration(prebase.ProtoM21Object, SlottedObjectMixin):
         '_unlinkedType',
         '_dotGroups',
         'expressionIsInferred',
+        'forceSingleComponent',
         '_client'
     )
 
@@ -1593,7 +1680,7 @@ class Duration(prebase.ProtoM21Object, SlottedObjectMixin):
                  expression.  For instance the duration of 0.5 is generally
                  an eighth note, but in the middle of a triplet group might be
                  better written as a dotted-eighth triplet.  If expressionIsInferred
-                 is True then `music21` can change it according to complex.  If
+                 is True then `music21` can change it according to context.  If
                  False, then the type, dots, and tuplets are considered immutable.
 
                  >>> d = duration.Duration(0.5)
@@ -1603,7 +1690,13 @@ class Duration(prebase.ProtoM21Object, SlottedObjectMixin):
                  >>> d = duration.Duration('eighth')
                  >>> d.expressionIsInferred
                  False
-                 '''}
+                 ''',
+                 'forceSingleComponent':
+                 '''If True, configure a single component (with an idiosyncratic tuplet)
+                  instead of attempting a solution with multiple components. If False,
+                  (default) an attempt is made at a multiple-component solution but will
+                  still create an idiosyncratic tuplet if no solution is found.''',
+                 }
 
     # INITIALIZER #
 
@@ -1640,6 +1733,8 @@ def __init__(self,
         self._linked = True
 
         self.expressionIsInferred = False
+        self.forceSingleComponent = False
+
         if typeOrDuration is not None:
             if isinstance(typeOrDuration, (int, float, fractions.Fraction)
                           ) and quarterLength is None:
@@ -1799,7 +1894,7 @@ def _updateComponents(self):
         # this update will not be necessary
         self._quarterLengthNeedsUpdating = False
         if self.linked and self.expressionIsInferred:
-            qlc = quarterConversion(self._qtrLength)
+            qlc = quarterConversion(self._qtrLength, forceSingleComponent=self.forceSingleComponent)
             self.components = list(qlc.components)
             if qlc.tuplet is not None:
                 self.tuplets = (qlc.tuplet,)
@@ -3803,6 +3898,18 @@ def testTupletDurations(self):
             Duration(fractions.Fraction(6 / 7)).fullName
         )
 
+    def testDeriveComponentsForTuplet(self):
+        self.assertEqual(
+            ('16th Triplet (5/6 QL) tied to ' * 4)
+            + '16th Triplet (5/6 QL) (5/6 total QL)',
+            Duration(fractions.Fraction(5 / 6)).fullName
+        )
+        self.assertEqual(
+            ('32nd Triplet (5/12 QL) tied to ' * 4)
+            + '32nd Triplet (5/12 QL) (5/12 total QL)',
+            Duration(fractions.Fraction(5 / 12)).fullName
+        )
+
     def testTinyDuration(self):
         # e.g. delta from chordify: 1/9 - 1/8 = 1/72
         # exercises quarterLengthToNonPowerOf2Tuplet()
@@ -3887,4 +3994,3 @@ def testExceptions(self):
 if __name__ == '__main__':
     import music21
     music21.mainTest(Test)  # , runTest='testAugmentOrDiminish')
-

music21/musicxml/m21ToXml.py

@@ -2865,15 +2865,19 @@ def fixupNotationFlat(self):
         '''
         Runs makeNotation on a flatStream, such as one lacking measures.
         '''
+        # Do this before makeNotation so that measures are filled correctly
+        self.stream = self.stream.splitAtDurations(recurse=True)[0]
+
         part = self.stream
         part.makeMutable()  # must mutate
         # try to add measures if none defined
         # returns a new stream w/ new Measures but the same objects
         part.makeNotation(meterStream=self.meterStream,
                           refStreamOrTimeRange=self.refStreamOrTimeRange,
                           inPlace=True)
-        # environLocal.printDebug(['fixupNotationFlat: post makeNotation, length',
-        #                    len(measureStream)])
+
+        # Do this again, since makeNotation() might create complex rests
+        self.stream = self.stream.splitAtDurations(recurse=True)[0]
 
         # after calling measuresStream, need to update Spanners, as a deepcopy
         # has been made
@@ -2900,6 +2904,9 @@ def fixupNotationMeasured(self):
 
         Changed in v7 -- no longer accepts `measureStream` argument.
         '''
+        # Split complex durations in place (fast if none found)
+        self.stream = self.stream.splitAtDurations(recurse=True)[0]
+
         part = self.stream
         measures = part.getElementsByClass(stream.Measure)
         first_measure = measures.first()
@@ -2934,9 +2941,10 @@ def fixupNotationMeasured(self):
                 part.makeBeams(inPlace=True)
             except exceptions21.StreamException as se:  # no measures or no time sig?
                 warnings.warn(MusicXMLWarning, str(se))
-        if not part.streamStatus.tuplets:
-            for m in measures:
-                for m_or_v in [m, *m.voices]:
+        for m in measures:
+            for m_or_v in [m, *m.voices]:
+                stream.makeNotation.makeTupletBrackets(m_or_v, inPlace=True)
+                if not m_or_v.streamStatus.tuplets:
                     stream.makeNotation.makeTupletBrackets(m_or_v, inPlace=True)
 
         if not self.spannerBundle:

music21/musicxml/test_m21ToXml.py

@@ -432,6 +432,16 @@ def testTextExpressionOffset(self):
         mxDirection = tree.find('part/measure/direction')
         self.assertEqual(mxDirection.get('placement'), 'above')
 
+    def testTupletBracketsMadeOnComponents(self):
+        s = stream.Stream()
+        s.insert(0, note.Note(quarterLength=(5 / 6)))
+        # Use GEX to go through wellformed object conversion
+        gex = GeneralObjectExporter(s)
+        tree = et_fromstring(gex.parse().decode('utf-8'))
+        # 3 sixteenth-triplets + 2 sixteenth-triplets
+        # tuplet start, tuplet stop, tuplet start, tuplet stop
+        self.assertEqual(len(tree.findall('.//tuplet')), 4)
+
     def testFullMeasureRest(self):
         s = converter.parse('tinynotation: 9/8 r1')
         r = s[note.Rest].first()

music21/stream/base.py

@@ -3129,6 +3129,7 @@ def processContainer(container: Stream):
                         sp.replaceSpannedElement(complexObj, objList[-1])
 
                 container.streamStatus.beams = False
+                container.streamStatus.tuplets = None
 
         # Handle "loose" objects in self (usually just Measure or Voice)
         processContainer(self)

music21/stream/makeNotation.py

@@ -1436,7 +1436,9 @@ def makeTupletBrackets(s: StreamType, *, inPlace=False) -> t.Optional[StreamType
 
             # this, below, is optional:
             # if next normal type is not the same as this one, also stop
-            elif tupletNext is None or completionCount >= completionTarget:
+            elif (tupletNext is None
+                   or completionCount == completionTarget
+                   or tupletPrevious.tupletMultiplier() != tupletObj.tupletMultiplier()):
                 tupletObj.type = 'stop'  # should be impossible once frozen...
                 completionTarget = None  # reset
                 completionCount = 0  # reset