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

music21/_version.py

@@ -42,7 +42,7 @@
 Changing this number invalidates old pickles -- do it if the old pickles create a problem.
 '''
 
-__version_info__ = (7, 3, 2)  # can be 4-tuple: (7, 0, 5, 'a2')
+__version_info__ = (7, 3, 3)  # can be 4-tuple: (7, 0, 5, 'a2')
 
 v = '.'.join(str(x) for x in __version_info__[0:3])
 if len(__version_info__) > 3 and __version_info__[3]:  # type: ignore

music21/base.py

@@ -28,7 +28,7 @@
 <class 'music21.base.Music21Object'>
 
 >>> music21.VERSION_STR
-'7.3.2'
+'7.3.3'
 
 Alternatively, after doing a complete import, these classes are available
 under the module "base":

music21/duration.py

@@ -497,7 +497,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)
 
@@ -506,8 +508,12 @@ def quarterConversion(qLen: OffsetQLIn) -> QuarterLengthConversion:
 
     Tuplet is a single :class:`~music21.duration.Tuplet` that adjusts all of the 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),),
@@ -603,13 +609,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:
 
@@ -627,6 +655,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
@@ -667,7 +713,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(
@@ -681,10 +727,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!
@@ -1545,6 +1621,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 #
@@ -1562,9 +1648,20 @@ class Duration(prebase.ProtoM21Object, SlottedObjectMixin):
         '_unlinkedType',
         '_dotGroups',
         'expressionIsInferred',
+        'forceSingleComponent',
         '_client'
     )
 
+    _DOC_ATTR = {'expressionIsInferred':
+                 '''Boolean indicating whether this duration was created from a
+                 number rather than a type and thus can be reexpressed.''',
+                 '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 #
 
     def __init__(self, *arguments, **keywords):
@@ -1591,6 +1688,7 @@ def __init__(self, *arguments, **keywords):
         self._linked = True
 
         self.expressionIsInferred = False
+        self.forceSingleComponent = False
         for a in arguments:
             if common.isNum(a) and 'quarterLength' not in keywords:
                 keywords['quarterLength'] = a
@@ -1746,7 +1844,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,)
@@ -3741,6 +3839,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()

music21/musicxml/m21ToXml.py

@@ -2558,11 +2558,6 @@ def parse(self):
             raise MusicXMLExportException(
                 'Cannot export with makeNotation=False if there are no measures')
 
-        # Split complex durations in place (fast if none found)
-        # must do after fixupNotationFlat(), which may create complex durations
-        if self.makeNotation:
-            self.stream = self.stream.splitAtDurations(recurse=True)[0]
-
         # make sure that all instances of the same class have unique ids
         self.spannerBundle.setIdLocals()
 
@@ -2707,15 +2702,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
@@ -2742,6 +2741,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()
@@ -2776,8 +2778,9 @@ def fixupNotationMeasured(self):
                 part.makeBeams(inPlace=True)
             except exceptions21.StreamException:  # no measures or no time sig?
                 pass
-        if part.streamStatus.haveTupletBracketsBeenMade() is False:
-            stream.makeNotation.makeTupletBrackets(part, inPlace=True)
+        # Always make tuplet brackets, since splitAtDurations() may have created some
+        for m in measures:
+            stream.makeNotation.makeTupletBrackets(m, inPlace=True)
 
         if not self.spannerBundle:
             self.spannerBundle = part.spannerBundle
@@ -6979,6 +6982,14 @@ 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)))
+        tree = self.getET(s)
+        # 3 sixteenth-triplets + 2 sixteenth-triplets
+        # tuplet start, tuplet stop, tuplet start, tuplet stop
+        self.assertEqual(len(tree.findall('.//tuplet')), 4)
+
     def testFullMeasureRest(self):
         from music21 import converter
         s = converter.parse('tinynotation: 9/8 r1')

music21/stream/makeNotation.py

@@ -1448,7 +1448,9 @@ def makeTupletBrackets(s: 'music21.stream.Stream', *, inPlace=False):
 
             # 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