abjad.duration

abjad.duration.durations(items)	Changes items to durations.
abjad.duration.is_fraction(argument)	Is true when argument is fraction (but not duration).
abjad.duration.is_offset(argument)	Is true when argument is offset.
abjad.duration.offset(n[, d])	Makes offset from n.
abjad.duration.pair_with_denominator(...)	Spells fraction as pair with denominator.
abjad.duration.Duration(numerator[, denominator])	Value duration.
abjad.duration.Offset(fraction[, displacement])	Offset.
abjad.duration.Ratio(numerator, denominator)	Ratio.

abjad.duration.durations(items: list) → list[Duration]

Changes items to durations.

>>> items = [(15, 8), (3, 8), abjad.TimeSignature((3, 4))]
>>> abjad.duration.durations(items)
[Duration(numerator=15, denominator=8), Duration(numerator=3, denominator=8), Duration(numerator=3, denominator=4)]

abjad.duration.is_fraction(argument: object) → bool

Is true when argument is fraction (but not duration).

>>> abjad.duration.is_fraction(abjad.Fraction(1, 4))
True

>>> abjad.duration.is_fraction(abjad.Offset(abjad.Fraction(1, 4)))
False

>>> abjad.duration.is_fraction((1, 4))
False

>>> abjad.duration.is_fraction(0)
False

abjad.duration.is_offset(argument: object) → bool

Is true when argument is offset.

>>> abjad.duration.is_offset(abjad.Fraction(1, 4))
False

>>> abjad.duration.is_offset(abjad.Offset(abjad.Fraction(1, 4)))
True

>>> abjad.duration.is_offset((1, 4))
False

>>> abjad.duration.is_offset(0)
False

abjad.duration.offset(n: int, d: int | None = None) → Offset

Makes offset from n.

>>> abjad.duration.offset(1)
Offset(Fraction(1, 1))

abjad.duration.pair_with_denominator(fraction: Fraction, denominator: int) → tuple[int, int]

Spells fraction as pair with denominator.

>>> for numerator in range(12):
...     fraction = abjad.Fraction(numerator, 6)
...     pair = abjad.duration.pair_with_denominator(fraction, 6)
...     print(fraction, pair)
... 
0 (0, 6)
1/6 (1, 6)
1/3 (2, 6)
1/2 (3, 6)
2/3 (4, 6)
5/6 (5, 6)
1 (6, 6)
7/6 (7, 6)
4/3 (8, 6)
3/2 (9, 6)
5/3 (10, 6)
11/6 (11, 6)

>>> for numerator in range(12):
...     fraction = abjad.Fraction(numerator, 6)
...     pair = abjad.duration.pair_with_denominator(fraction, 8)
...     print(fraction, pair)
... 
0 (0, 8)
1/6 (1, 6)
1/3 (1, 3)
1/2 (4, 8)
2/3 (2, 3)
5/6 (5, 6)
1 (8, 8)
7/6 (7, 6)
4/3 (4, 3)
3/2 (12, 8)
5/3 (5, 3)
11/6 (11, 6)

>>> for numerator in range(12):
...     fraction = abjad.Fraction(numerator, 6)
...     pair = abjad.duration.pair_with_denominator(fraction, 12)
...     print(fraction, pair)
... 
0 (0, 12)
1/6 (2, 12)
1/3 (4, 12)
1/2 (6, 12)
2/3 (8, 12)
5/6 (10, 12)
1 (12, 12)
7/6 (14, 12)
4/3 (16, 12)
3/2 (18, 12)
5/3 (20, 12)
11/6 (22, 12)

class abjad.duration.Duration(numerator: int, denominator: int = 1)

Value duration.

>>> abjad.Duration(2, 8)
Duration(numerator=1, denominator=4)

as_fraction()	Returns value duration as fraction.
as_integer_ratio()	Changes duration to (numerator, denominator) pair.
dot_count()	Gets dot count.
exponent()	Gets base-2 exponent.
flag_count()	Gets flag count.
is_assignable()	Is true when duration is assignable.
is_dyadic()	Is true when denominator of duration is integer power of two.
lilypond_duration_string()	Gets LilyPond duration string.
pair()	Gets (numerator, denominator) pair.
reciprocal()	Gets reciprocal.

as_fraction() → Fraction

Returns value duration as fraction.

>>> abjad.Duration(1, 4).as_fraction()
Fraction(1, 4)

as_integer_ratio() → tuple[int, int]

Changes duration to (numerator, denominator) pair.

>>> abjad.Duration(1, 4).as_integer_ratio()
(1, 4)

dot_count() → int

Gets dot count.

Dot count defined equal to number of dots required to notate duration. Raises assignability error when duration is not assignable.

>>> for n in range(1, 16 + 1):
...     duration = abjad.Duration(n, 16)
...     fraction = duration.as_fraction()
...     sixteenths = abjad.duration.pair_with_denominator(fraction, 16)
...     numerator, denominator = sixteenths
...     try:
...         dot_count = duration.dot_count()
...         string = f"{numerator}/{denominator}\t{dot_count}"
...         print(string)
...     except abjad.AssignabilityError:
...         print(f"{numerator}/{denominator}\t--")
... 
1/16	0
2/16	0
3/16	1
4/16	0
5/16	--
6/16	1
7/16	2
8/16	0
9/16	--
10/16	--
11/16	--
12/16	1
13/16	--
14/16	2
15/16	3
16/16	0

exponent() → int

Gets base-2 exponent.

>>> for numerator in range(1, 16 + 1):
...     duration = abjad.Duration(numerator, 16)
...     fraction = duration.as_fraction()
...     exponent = duration.exponent()
...     sixteenths = abjad.duration.pair_with_denominator(fraction, 16)
...     numerator, denominator = sixteenths
...     print(f"{numerator}/{denominator}\t{exponent!s}")
... 
1/16	4
2/16	3
3/16	3
4/16	2
5/16	2
6/16	2
7/16	2
8/16	1
9/16	1
10/16	1
11/16	1
12/16	1
13/16	1
14/16	1
15/16	1
16/16	0

flag_count() → int

Gets flag count.

Flag count defined equal to number of flags required to notate duration.

>>> for n in range(1, 16 + 1):
...     duration = abjad.Duration(n, 64)
...     fraction = duration.as_fraction()
...     sixty_fourths = abjad.duration.pair_with_denominator(fraction, 64)
...     numerator, denominator = sixty_fourths
...     flag_count = duration.flag_count()
...     print(f"{numerator}/{denominator}\t{flag_count}")
... 
1/64	4
2/64	3
3/64	3
4/64	2
5/64	2
6/64	2
7/64	2
8/64	1
9/64	1
10/64	1
11/64	1
12/64	1
13/64	1
14/64	1
15/64	1
16/64	0

is_assignable() → bool

Is true when duration is assignable.

>>> for numerator in range(0, 16 + 1):
...     duration = abjad.Duration(numerator, 16)
...     fraction = duration.as_fraction()
...     sixteenths = abjad.duration.pair_with_denominator(fraction, 16)
...     print(f"{sixteenths[0]}/{sixteenths[1]}\t{duration.is_assignable()}")
... 
0/16	False
1/16	True
2/16	True
3/16	True
4/16	True
5/16	False
6/16	True
7/16	True
8/16	True
9/16	False
10/16	False
11/16	False
12/16	True
13/16	False
14/16	True
15/16	True
16/16	True

is_dyadic() → bool

Is true when denominator of duration is integer power of two.

>>> for n in range(1, 16 + 1):
...     duration = abjad.Duration(1, n)
...     result = duration.is_dyadic()
...     print(f"1/{n}\t{result}")
... 
1/1	True
1/2	True
1/3	False
1/4	True
1/5	False
1/6	False
1/7	False
1/8	True
1/9	False
1/10	False
1/11	False
1/12	False
1/13	False
1/14	False
1/15	False
1/16	True

lilypond_duration_string() → str

Gets LilyPond duration string.

>>> abjad.Duration(3, 16).lilypond_duration_string()
'8.'

pair() → tuple[int, int]

Gets (numerator, denominator) pair.

reciprocal() → Duration

Gets reciprocal.

>>> abjad.Duration(3, 7).reciprocal()
Duration(numerator=7, denominator=3)

class abjad.duration.Offset(fraction: Fraction, displacement: Duration | None = None)

Offset.

>>> fraction = abjad.Fraction(3, 16)
>>> abjad.Offset(fraction)
Offset(Fraction(3, 16))

>>> displacement = abjad.Duration(-1, 16)
>>> abjad.Offset(fraction, displacement=displacement)
Offset(Fraction(3, 16), displacement=Duration(numerator=-1, denominator=16))

duration()	Changes offset to duration.
remove_displacement()	Makes new offset equal to this offset without displacement.

duration() → Duration

Changes offset to duration.

>>> fraction = abjad.Fraction(1, 4)
>>> offset = abjad.Offset(fraction)
>>> offset.duration()
Duration(numerator=1, denominator=4)

remove_displacement()

Makes new offset equal to this offset without displacement.

>>> duration = abjad.Duration(-1, 16)
>>> offset = abjad.Offset(abjad.Fraction(1, 4), displacement=duration)
>>> offset
Offset(Fraction(1, 4), displacement=Duration(numerator=-1, denominator=16))

>>> offset.remove_displacement()
Offset(Fraction(1, 4))

class abjad.duration.Ratio(numerator: int, denominator: int)

Ratio.

>>> abjad.Ratio(6, 4)
Ratio(numerator=6, denominator=4)

Abjad ratios are two-term, unreduced integer ratios of the form n:d.

These are used primarily in modeling tuplet ratios like 3:2 and 6:4.

fraction()	Changes (unreduced) ratio to (reduced) fraction.
is_augmented()	Is true when ratio numerator is less than ratio denominator.
is_canonical()	Is true when ratio is normalized diminution.
is_diminished()	Is true when ratio denominator is less than ratio numerator.
is_dyadic()	Is true when ratio denominator is nonnegative integer power of two.
is_normalized()	Is true when fraction form of ratio is greater than 1/2 and less than 2.
is_reduced()	Is true when ratio numerator and denominator are relatively prime.
is_trivial()	Is true when ratio numerator equals ratio denominator.
reciprocal()	Get reciprocal of ratio.

fraction()

Changes (unreduced) ratio to (reduced) fraction.

>>> abjad.Ratio(6, 4).fraction()
Fraction(3, 2)

is_augmented() → bool

Is true when ratio numerator is less than ratio denominator.

>>> abjad.Ratio(6, 4).is_augmented()
False

>>> abjad.Ratio(3, 2).is_augmented()
False

>>> abjad.Ratio(4, 6).is_augmented()
True

>>> abjad.Ratio(2, 3).is_augmented()
True

>>> abjad.Ratio(2, 2).is_augmented()
False

>>> abjad.Ratio(1, 1).is_augmented()
False

is_canonical() → bool

Is true when ratio is normalized diminution.

>>> abjad.Ratio(6, 4).is_canonical()
True

>>> abjad.Ratio(3, 2).is_canonical()
True

>>> abjad.Ratio(4, 6).is_canonical()
False

>>> abjad.Ratio(2, 3).is_canonical()
False

>>> abjad.Ratio(2, 2).is_canonical()
False

>>> abjad.Ratio(1, 1).is_canonical()
False

is_diminished() → bool

Is true when ratio denominator is less than ratio numerator.

>>> abjad.Ratio(6, 4).is_diminished()
True

>>> abjad.Ratio(3, 2).is_diminished()
True

>>> abjad.Ratio(4, 6).is_diminished()
False

>>> abjad.Ratio(2, 3).is_diminished()
False

>>> abjad.Ratio(2, 2).is_diminished()
False

>>> abjad.Ratio(1, 1).is_diminished()
False

is_dyadic() → bool

Is true when ratio denominator is nonnegative integer power of two.

>>> abjad.Ratio(6, 4).is_dyadic()
True

>>> abjad.Ratio(3, 2).is_dyadic()
True

>>> abjad.Ratio(4, 6).is_dyadic()
False

>>> abjad.Ratio(2, 3).is_dyadic()
False

>>> abjad.Ratio(2, 2).is_dyadic()
True

>>> abjad.Ratio(1, 1).is_dyadic()
True

is_normalized() → bool

Is true when fraction form of ratio is greater than 1/2 and less than 2.

>>> abjad.Ratio(6, 4).is_normalized()
True

>>> abjad.Ratio(3, 2).is_normalized()
True

>>> abjad.Ratio(4, 6).is_normalized()
True

>>> abjad.Ratio(2, 3).is_normalized()
True

>>> abjad.Ratio(2, 2).is_normalized()
True

>>> abjad.Ratio(1, 1).is_normalized()
True

>>> abjad.Ratio(10, 4).is_normalized()
False

>>> abjad.Ratio(4, 10).is_normalized()
False

>>> abjad.Ratio(9, 4).is_normalized()
False

>>> abjad.Ratio(4, 9).is_normalized()
False

is_reduced() → bool

Is true when ratio numerator and denominator are relatively prime.

>>> abjad.Ratio(6, 4).is_reduced()
False

>>> abjad.Ratio(3, 2).is_reduced()
True

>>> abjad.Ratio(4, 6).is_reduced()
False

>>> abjad.Ratio(2, 3).is_reduced()
True

>>> abjad.Ratio(2, 2).is_reduced()
False

>>> abjad.Ratio(1, 1).is_reduced()
True

is_trivial() → bool

Is true when ratio numerator equals ratio denominator.

>>> abjad.Ratio(6, 4).is_trivial()
False

>>> abjad.Ratio(3, 2).is_trivial()
False

>>> abjad.Ratio(4, 6).is_trivial()
False

>>> abjad.Ratio(2, 3).is_trivial()
False

>>> abjad.Ratio(2, 2).is_trivial()
True

>>> abjad.Ratio(1, 1).is_trivial()
True

reciprocal() → Ratio

Get reciprocal of ratio.

>>> abjad.Ratio(6, 4).reciprocal()
Ratio(numerator=4, denominator=6)