示例#1
0
文件: Duration.py 项目: gsy/gmajor
    def durations_to_nonreduced_fractions(
        durations: typing.List,
        ) -> typing.List[mathtools.NonreducedFraction]:
        """
        Changes ``durations`` to nonreduced fractions sharing least common
        denominator.

        ..  container:: example

            Changes durations to nonreduced fractions:

            >>> durations = [abjad.Duration(2, 4), 3, (5, 16)]
            >>> result = abjad.Duration.durations_to_nonreduced_fractions(durations)
            >>> for x in result:
            ...     x
            ...
            NonreducedFraction(8, 16)
            NonreducedFraction(48, 16)
            NonreducedFraction(5, 16)

        """
        durations_ = [Duration(_) for _ in durations]
        denominators = [_.denominator for _ in durations_]
        lcd = mathtools.least_common_multiple(*denominators)
        nonreduced_fractions = [
            mathtools.NonreducedFraction(_).with_denominator(lcd)
            for _ in durations_
            ]
        return nonreduced_fractions
示例#2
0
    def __call__(self, pitches, durations) -> Selection:
        """
        Calls note-maker on ``pitches`` and ``durations``.
        """
        from .Tuplet import Tuplet

        if isinstance(pitches, str):
            pitches = pitches.split()
        if not isinstance(pitches, collections.abc.Iterable):
            pitches = [pitches]
        if isinstance(durations, (numbers.Number, tuple)):
            durations = [durations]
        nonreduced_fractions = Sequence(
            [mathtools.NonreducedFraction(_) for _ in durations])
        size = max(len(nonreduced_fractions), len(pitches))
        nonreduced_fractions = nonreduced_fractions.repeat_to_length(size)
        pitches = Sequence(pitches).repeat_to_length(size)
        durations = Duration._group_by_implied_prolation(nonreduced_fractions)
        result: typing.List[typing.Union[Note, Tuplet]] = []
        for duration in durations:
            # get factors in denominator of duration group duration not 1 or 2
            factors = set(mathtools.factors(duration[0].denominator))
            factors.discard(1)
            factors.discard(2)
            ps = pitches[0:len(duration)]
            pitches = pitches[len(duration):]
            if len(factors) == 0:
                result.extend(
                    self._make_unprolated_notes(
                        ps,
                        duration,
                        increase_monotonic=self.increase_monotonic,
                        tag=self.tag,
                    ))
            else:
                # compute prolation
                denominator = duration[0].denominator
                numerator = mathtools.greatest_power_of_two_less_equal(
                    denominator)
                multiplier = Multiplier(numerator, denominator)
                ratio = multiplier.reciprocal
                duration = [ratio * Duration(d) for d in duration]
                ns = self._make_unprolated_notes(
                    ps,
                    duration,
                    increase_monotonic=self.increase_monotonic,
                    tag=self.tag,
                )
                tuplet = Tuplet(multiplier, ns)
                result.append(tuplet)
        return Selection(result)
示例#3
0
 def _group_by_implied_prolation(durations):
     durations = [
         mathtools.NonreducedFraction(duration) for duration in durations
     ]
     assert 0 < len(durations)
     group = [durations[0]]
     result = [group]
     for d in durations[1:]:
         d_f = set(mathtools.factors(d.denominator))
         d_f.discard(2)
         gd_f = set(mathtools.factors(group[0].denominator))
         gd_f.discard(2)
         if d_f == gd_f:
             group.append(d)
         else:
             group = [d]
             result.append(group)
     return result
示例#4
0
    def with_denominator(self, denominator) -> mathtools.NonreducedFraction:
        """
        Changes duration to nonreduced fraction with ``denominator``.

        ..  container:: example

            Changes duration to nonreduced fraction:

            >>> duration = abjad.Duration(1, 4)
            >>> for denominator in (4, 8, 16, 32):
            ...     print(duration.with_denominator(denominator))
            ...
            1/4
            2/8
            4/16
            8/32

        """
        nonreduced_fraction = mathtools.NonreducedFraction(self)
        return nonreduced_fraction.with_denominator(denominator)
示例#5
0
 def t_FRACTION(self, t):
     r'([1-9]\d*/[1-9]\d*)'
     parts = t.value.split('/')
     t.value = mathtools.NonreducedFraction(int(parts[0]), int(parts[1]))
     return t
示例#6
0
    for subdivision in division:
        for _ in subdivision:
            number_of_measures += 1
    measures_per_stage.append(number_of_measures)

# make time signatures from resulting divisions
time_signatures = []
for division in divisions:
    stage = []
    for subdivision in division:
        stage_division = []
        for duration in subdivision:
            if duration.denominator < 8:
                multiplier = int(8 / duration.denominator)
                duration = mathtools.NonreducedFraction(
                    duration.numerator * multiplier,
                    duration.denominator * multiplier
                )
            time_signature = abjad.TimeSignature(duration)
            stage_division.append(time_signature)
        stage.append(stage_division)
    time_signatures.append(stage)


subsection_indices = [
    [0, 3, 5, 9, 12,16, 20, 22, 25,27,30, 32],
    [0, 4, 7, 11, 13, 16, 18, 22, 25, 27, 31, 35],
    [0, 3, 5, 9, 13, 16, 20, 22, 26, 29, 32, 34, 38, 41, 45],
    [0, 3, 5, 9, 13, 16, 20, 22, 25, 27],
    [0, 3, 5, 9, 12, 14, 17, 20, 22, 26, 30],
]