# Duration¶

class `abjad.utilities.Duration.``Duration`

Duration.

Initializes from integer numerator:

```>>> abjad.Duration(3)
Duration(3, 1)
```

Initializes from integer numerator and denominator:

```>>> abjad.Duration(3, 16)
Duration(3, 16)
```

Initializes from integer-equivalent numeric numerator:

```>>> abjad.Duration(3.0)
Duration(3, 1)
```

Initializes from integer-equivalent numeric numerator and denominator:

```>>> abjad.Duration(3.0, 16)
Duration(3, 16)
```

Initializes from integer-equivalent singleton:

```>>> abjad.Duration((3,))
Duration(3, 1)
```

Initializes from integer-equivalent pair:

```>>> abjad.Duration((3, 16))
Duration(3, 16)
```

Initializes from other duration:

```>>> abjad.Duration(abjad.Duration(3, 16))
Duration(3, 16)
```

Intializes from fraction:

```>>> abjad.Duration(abjad.Fraction(3, 16))
Duration(3, 16)
```

Initializes from solidus string:

```>>> abjad.Duration('3/16')
Duration(3, 16)
```

Initializes from nonreduced fraction:

```>>> abjad.Duration(abjad.NonreducedFraction(6, 32))
Duration(3, 16)
```

Durations inherit from built-in fraction:

```>>> isinstance(abjad.Duration(3, 16), abjad.Fraction)
True
```

Durations are numbers:

```>>> import numbers
```
```>>> isinstance(abjad.Duration(3, 16), numbers.Number)
True
```

Attributes Summary

 `__abs__` Gets absolute value of duration. `__add__` Adds duration to `arguments`. `__div__` Divides duration by `arguments`. `__divmod__` Equals the pair (duration // `arguments`, duration % `arguments`). `__eq__` Is true when duration equals `argument`. `__format__` Formats duration. `__ge__` Is true when duration is greater than or equal to `argument`. `__gt__` Is true when duration is greater than `argument`. `__hash__` Hashes duration. `__le__` Is true when duration is less than or equal to `argument`. `__lt__` Is true when duration is less than `argument`. `__mod__` Modulus operator applied to duration. `__mul__` Duration multiplied by `arguments`. `__neg__` Negates duration. `__new__` Create and return a new object. `__pos__` Get positive duration. `__pow__` Raises duration to `arguments` power. `__radd__` Adds `arguments` to duration. `__rdiv__` Divides `arguments` by duration. `__rdivmod__` Documentation required. `__rmod__` Documentation required. `__rmul__` Multiplies `arguments` by duration. `__rpow__` Raises `arguments` to the power of duration. `__rsub__` Subtracts duration from `arguments`. `__rtruediv__` Documentation required. `__sub__` Subtracts `arguments` from duration. `__truediv__` Documentation required. `dot_count` Gets dot count. `durations_to_nonreduced_fractions` Changes `durations` to nonreduced fractions sharing least common denominator. `equal_or_greater_assignable` Gets assignable duration equal to or just greater than this duration. `equal_or_greater_power_of_two` Gets duration equal or just greater power of two. `equal_or_lesser_assignable` Gets assignable duration equal or just less than this duration. `equal_or_lesser_power_of_two` Gets duration of the form `d**2` equal to or just less than this duration. `flag_count` Gets flag count. `from_lilypond_duration_string` Initializes duration from LilyPond duration string. `has_power_of_two_denominator` Is true when duration is an integer power of two. `implied_prolation` Gets implied prolation. `is_assignable` Is true when duration is assignable. `is_token` Is true when `argument` correctly initializes a duration. `lilypond_duration_string` Gets LilyPond duration string. `pair` Gets numerator and denominator. `prolation_string` Gets prolation string. `reciprocal` Gets reciprocal. `to_clock_string` Changes duration to clock string. `to_score_markup` Changes duration to score markup. `with_denominator` Changes duration to nonreduced fraction with `denominator`.

Special methods

`__abs__`(*arguments)

Gets absolute value of duration.

Returns nonnegative duration.

`__add__`(*arguments)

Adds duration to `arguments`.

Returns duration when `arguments` is a duration:

```>>> duration_1 = abjad.Duration(1, 2)
>>> duration_1 + duration_2
Duration(2, 1)
```

Returns nonreduced fraction when `arguments` is a nonreduced fraction:

```>>> duration = abjad.Duration(1, 2)
>>> duration + nonreduced_fraction
NonreducedFraction(6, 6)
```

Returns duration.

`(Fraction).``__bool__`()

a != 0

`(Fraction).``__ceil__`()

Will be math.ceil(a) in 3.0.

`(Real).``__complex__`()

complex(self) == complex(float(self), 0)

`(Fraction).``__copy__`()
`(Fraction).``__deepcopy__`(memo)
`__div__`(*arguments)

Divides duration by `arguments`.

```>>> abjad.Duration(1) / abjad.NonreducedFraction(3, 3)
NonreducedFraction(3, 3)
```
```>>> abjad.NonreducedFraction(3, 3) / abjad.Duration(1)
NonreducedFraction(3, 3)
```

Returns multiplier.

`__divmod__`(*arguments)

Equals the pair (duration // `arguments`, duration % `arguments`).

Returns pair.

`__eq__`(argument)

Is true when duration equals `argument`.

Returns true or false.

`(Rational).``__float__`()

float(self) = self.numerator / self.denominator

It’s important that this conversion use the integer’s “true” division rather than casting one side to float before dividing so that ratios of huge integers convert without overflowing.

`(Fraction).``__floor__`()

Will be math.floor(a) in 3.0.

`(Fraction).``__floordiv__`(b)

a // b

`__format__`(format_specification='')

Formats duration.

Set `format_specification` to `''` or `'storage'`. Interprets `''` equal to `'storage'`.

Returns string.

`__ge__`(argument)

Is true when duration is greater than or equal to `argument`.

Returns true or false.

`__gt__`(argument)

Is true when duration is greater than `argument`.

Returns true or false.

`__hash__`()

Hashes duration.

Required to be explicitly redefined on Python 3 if __eq__ changes.

Returns integer.

`__le__`(argument)

Is true when duration is less than or equal to `argument`.

Returns true or false.

`__lt__`(argument)

Is true when duration is less than `argument`.

Returns true or false.

`__mod__`(*arguments)

Modulus operator applied to duration.

Returns duration.

`__mul__`(*arguments)

Duration multiplied by `arguments`.

Returns a new duration when `arguments` is a duration:

```>>> duration_1 = abjad.Duration(1, 2)
>>> duration_1 * duration_2
Duration(3, 4)
```

Returns nonreduced fraction when `arguments` is a nonreduced fraction:

```>>> duration = abjad.Duration(1, 2)
>>> duration * nonreduced_fraction
NonreducedFraction(3, 12)
```

Returns duration or nonreduced fraction.

`__neg__`(*arguments)

Negates duration.

Returns new duration.

static `__new__`(class_, *arguments)

Create and return a new object. See help(type) for accurate signature.

`__pos__`(*arguments)

Get positive duration.

Returns new duration.

`__pow__`(*arguments)

Raises duration to `arguments` power.

Returns new duration.

`__radd__`(*arguments)

Adds `arguments` to duration.

Returns new duration.

`__rdiv__`(*arguments)

Divides `arguments` by duration.

Returns new duration.

`__rdivmod__`(*arguments)

Documentation required.

`(AbjadObject).``__repr__`()

Gets interpreter representation of Abjad object.

Returns string.

`(Fraction).``__rfloordiv__`(a)

a // b

`__rmod__`(*arguments)

Documentation required.

`__rmul__`(*arguments)

Multiplies `arguments` by duration.

Returns new duration.

`(Fraction).``__round__`(ndigits=None)

Will be round(self, ndigits) in 3.0.

Rounds half toward even.

`__rpow__`(*arguments)

Raises `arguments` to the power of duration.

Returns new duration.

`__rsub__`(*arguments)

Subtracts duration from `arguments`.

Returns new duration.

`__rtruediv__`(*arguments)

Documentation required.

Returns new duration.

`(Fraction).``__str__`()

str(self)

`__sub__`(*arguments)

Subtracts `arguments` from duration.

```>>> abjad.Duration(1, 2) - abjad.NonreducedFraction(2, 8)
NonreducedFraction(2, 8)
```
```>>> abjad.NonreducedFraction(4, 8) - abjad.Duration(1, 4)
NonreducedFraction(2, 8)
```

Returns new duration.

`__truediv__`(*arguments)

Documentation required.

`(Fraction).``__trunc__`()

trunc(a)

Methods

`(Real).``conjugate`()

Conjugate is a no-op for Reals.

`(Fraction).``limit_denominator`(max_denominator=1000000)

Closest Fraction to self with denominator at most max_denominator.

```>>> Fraction('3.141592653589793').limit_denominator(10)
Fraction(22, 7)
```
```>>> Fraction('3.141592653589793').limit_denominator(100)
Fraction(311, 99)
```
```>>> Fraction(4321, 8765).limit_denominator(10000)
Fraction(4321, 8765)
```
`to_clock_string`()

Changes duration to clock string.

Changes duration to clock string:

```>>> note = abjad.Note("c'4")
>>> clock_string = duration.to_clock_string()
>>> clock_string
"1'57''"
```
```>>> string = '"{}"'.format(clock_string)
```

Rounds down to nearest second.

Returns string.

`to_score_markup`()

Changes duration to score markup.

Changes assignable duration to score markup:

```>>> markup = abjad.Duration(3, 16).to_score_markup()
```

Changes nonassignable duration to score markup:

```>>> markup = abjad.Duration(5, 16).to_score_markup()
```

Override tuplet number text like this:

```>>> tuplet = abjad.Tuplet((5, 7), "c'16 c' c' c' c' c' c'")
>>> markup = duration.to_score_markup()
>>> markup = markup.scale((0.75, 0.75))
```

Returns markup.

`with_denominator`(denominator)

Changes duration to nonreduced fraction with `denominator`.

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
```

Returns new duration.

Class & static methods

static `durations_to_nonreduced_fractions`(durations)

Changes `durations` to nonreduced fractions sharing least common denominator.

Changes durations to nonreduced fractions:

```>>> durations = [abjad.Duration(2, 4), 3, (5, 16)]
>>> for x in result:
...     x
...
NonreducedFraction(8, 16)
NonreducedFraction(48, 16)
NonreducedFraction(5, 16)
```
Return type: `List`[`NonreducedFraction`]
classmethod `(Fraction).``from_decimal`(dec)

Converts a finite Decimal instance to a rational number, exactly.

classmethod `(Fraction).``from_float`(f)

Converts a finite float to a rational number, exactly.

Beware that Fraction.from_float(0.3) != Fraction(3, 10).

static `from_lilypond_duration_string`(lilypond_duration_string)

Initializes duration from LilyPond duration string.

Initializes duration from LilyPond duration string:

```>>> abjad.Duration.from_lilypond_duration_string('8.')
Duration(3, 16)
```

Returns duration.

static `is_token`(argument)

Is true when `argument` correctly initializes a duration.

Is true when expression is a duration token:

```>>> abjad.Duration.is_token('8.')
True
```

Returns true or false.

`(Fraction).``denominator`
`dot_count`

Gets dot count.

Gets dot count:

```>>> for n in range(1, 16 + 1):
...     try:
...         sixteenths = duration.with_denominator(16)
...         dot_count = duration.dot_count
...         string = f'{sixteenths!s}\t{dot_count}'
...         print(string)
...         sixteenths = duration.with_denominator(16)
...         print(f'{sixteenths!s}\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
```

Dot count defined equal to number of dots required to notate duration.

Raises assignability error when duration is not assignable.

Returns positive integer.

`equal_or_greater_assignable`

Gets assignable duration equal to or just greater than this duration.

Gets equal-or-greater assignable duration:

```>>> for numerator in range(1, 16 + 1):
...     result = duration.equal_or_greater_assignable
...     sixteenths = duration.with_denominator(16)
...     print(f'{sixteenths!s}\t{result!s}')
...
1/16	1/16
2/16	1/8
3/16	3/16
4/16	1/4
5/16	3/8
6/16	3/8
7/16	7/16
8/16	1/2
9/16	3/4
10/16	3/4
11/16	3/4
12/16	3/4
13/16	7/8
14/16	7/8
15/16	15/16
16/16	1
```

Returns new duration.

`equal_or_greater_power_of_two`

Gets duration equal or just greater power of two.

Gets equal-or-greater power-of-two:

```>>> for numerator in range(1, 16 + 1):
...     result = duration.equal_or_greater_power_of_two
...     sixteenths = duration.with_denominator(16)
...     print(f'{sixteenths!s}\t{result!s}')
...
1/16	1/16
2/16	1/8
3/16	1/4
4/16	1/4
5/16	1/2
6/16	1/2
7/16	1/2
8/16	1/2
9/16	1
10/16	1
11/16	1
12/16	1
13/16	1
14/16	1
15/16	1
16/16	1
```

Returns new duration.

`equal_or_lesser_assignable`

Gets assignable duration equal or just less than this duration.

Gets equal-or-lesser assignable duration:

```>>> for numerator in range(1, 16 + 1):
...     result = duration.equal_or_lesser_assignable
...     sixteenths = duration.with_denominator(16)
...     print(f'{sixteenths!s}\t{result!s}')
...
1/16	1/16
2/16	1/8
3/16	3/16
4/16	1/4
5/16	1/4
6/16	3/8
7/16	7/16
8/16	1/2
9/16	1/2
10/16	1/2
11/16	1/2
12/16	3/4
13/16	3/4
14/16	7/8
15/16	15/16
16/16	1
```

Returns new duration.

`equal_or_lesser_power_of_two`

Gets duration of the form `d**2` equal to or just less than this duration.

Gets equal-or-lesser power-of-two:

```>>> for numerator in range(1, 16 + 1):
...     result = duration.equal_or_lesser_power_of_two
...     sixteenths = duration.with_denominator(16)
...     print(f'{sixteenths!s}\t{result!s}')
...
1/16	1/16
2/16	1/8
3/16	1/8
4/16	1/4
5/16	1/4
6/16	1/4
7/16	1/4
8/16	1/2
9/16	1/2
10/16	1/2
11/16	1/2
12/16	1/2
13/16	1/2
14/16	1/2
15/16	1/2
16/16	1
```

Returns new duration.

`flag_count`

Gets flag count.

Gets flag count:

```>>> for n in range(1, 16 + 1):
...     sixty_fourths = duration.with_denominator(64)
...     print(f'{sixty_fourths!s}\t{duration.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
```

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

Returns nonnegative integer.

`has_power_of_two_denominator`

Is true when duration is an integer power of two.

Is true when duration has power-of-two denominator:

```>>> for n in range(1, 16 + 1):
...     result = duration.has_power_of_two_denominator
...     print('{!s}\t{}'.format(duration, result))
...
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
```

Returns true or false.

`(Real).``imag`

Real numbers have no imaginary component.

`implied_prolation`

Gets implied prolation.

Gets implied prolation:

```>>> for denominator in range(1, 16 + 1):
...     result = duration.implied_prolation
...     print('{!s}\t{!s}'.format(duration, result))
...
1	1
1/2	1
1/3	2/3
1/4	1
1/5	4/5
1/6	2/3
1/7	4/7
1/8	1
1/9	8/9
1/10	4/5
1/11	8/11
1/12	2/3
1/13	8/13
1/14	4/7
1/15	8/15
1/16	1
```

Returns multipler.

`is_assignable`

Is true when duration is assignable.

Is true when duration is assignable:

```>>> for numerator in range(0, 16 + 1):
...     sixteenths = duration.with_denominator(16)
...     print('{!s}\t{}'.format(sixteenths, 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
```

Returns true or false.

`lilypond_duration_string`

Gets LilyPond duration string.

Gets LilyPond duration string:

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

Raises assignability error when duration is not assignable.

Returns string.

`(Fraction).``numerator`
`pair`

Gets numerator and denominator.

Gets pair:

```>>> abjad.Duration(3, 16).pair
(3, 16)
```

Returns integer pair.

`prolation_string`

Gets prolation string.

Gets prolation string:

```>>> abjad.Duration(3, 16).prolation_string
'16:3'
```

Returns string.

`(Real).``real`

Real numbers are their real component.

`reciprocal`

Gets reciprocal.

Gets reciprocal:

```>>> abjad.Duration(3, 7).reciprocal
Duration(7, 3)
```

Returns new duration.