# Multiplier¶

class `abjad.utilities.Multiplier.``Multiplier`

Multiplier.

Initializes from integer numerator:

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

Initializes from integer numerator and denominator:

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

Initializes from integer-equivalent numeric numerator:

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

Initializes from integer-equivalent numeric numerator and denominator:

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

Initializes from integer-equivalent singleton:

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

Initializes from integer-equivalent pair:

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

Initializes from other duration:

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

Intializes from fraction:

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

Initializes from solidus string:

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

Initializes from nonreduced fraction:

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

Multipliers inherit from built-in fraction:

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

Multipliers are numbers:

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

Attaching a multiplier to a score component multiplies that component’s duration:

```>>> note = abjad.Note("c'1")
c'1
```
```>>> multiplier = abjad.Multiplier(3, 8)
c'1 * 3/8
```

Attributes Summary

 `__mul__` Multiplier times duration gives duration. `from_dot_count` Makes multiplier from `dot_count`. `normalized` Is true when mutliplier is greater than `1/2` and less than `2`.

Special methods

`(Duration).``__abs__`(*arguments)

Gets absolute value of duration.

Returns nonnegative duration.

`(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)
`(Duration).``__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.

`(Duration).``__divmod__`(*arguments)

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

Returns pair.

`(Duration).``__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

`(Duration).``__format__`(format_specification='')

Formats duration.

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

Returns string.

`(Duration).``__ge__`(argument)

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

Returns true or false.

`(Duration).``__gt__`(argument)

Is true when duration is greater than `argument`.

Returns true or false.

`(Duration).``__hash__`()

Hashes duration.

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

Returns integer.

`(Duration).``__le__`(argument)

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

Returns true or false.

`(Duration).``__lt__`(argument)

Is true when duration is less than `argument`.

Returns true or false.

`(Duration).``__mod__`(*arguments)

Modulus operator applied to duration.

Returns duration.

`__mul__`(*arguments)

Multiplier times duration gives duration.

Returns duration.

`(Duration).``__neg__`(*arguments)

Negates duration.

Returns new duration.

static `(Duration).``__new__`(class_, *arguments)

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

`(Duration).``__pos__`(*arguments)

Get positive duration.

Returns new duration.

`(Duration).``__pow__`(*arguments)

Raises duration to `arguments` power.

Returns new duration.

`(Duration).``__radd__`(*arguments)

Adds `arguments` to duration.

Returns new duration.

`(Duration).``__rdiv__`(*arguments)

Divides `arguments` by duration.

Returns new duration.

`(Duration).``__rdivmod__`(*arguments)

Documentation required.

`(AbjadObject).``__repr__`()

Gets interpreter representation of Abjad object.

Returns string.

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

a // b

`(Duration).``__rmod__`(*arguments)

Documentation required.

`(Duration).``__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.

`(Duration).``__rpow__`(*arguments)

Raises `arguments` to the power of duration.

Returns new duration.

`(Duration).``__rsub__`(*arguments)

Subtracts duration from `arguments`.

Returns new duration.

`(Duration).``__rtruediv__`(*arguments)

Documentation required.

Returns new duration.

`(Fraction).``__str__`()

str(self)

`(Duration).``__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.

`(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)
```
`normalized`()

Is true when mutliplier is greater than `1/2` and less than `2`.

```>>> abjad.Multiplier(3, 2).normalized()
True
```

Returns true or false.

`(Duration).``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.

`(Duration).``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.

`(Duration).``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 `(Duration).``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.

static `from_dot_count`(dot_count)

Makes multiplier from `dot_count`.

```>>> abjad.Multiplier.from_dot_count(0)
Multiplier(1, 1)
```
```>>> abjad.Multiplier.from_dot_count(1)
Multiplier(3, 2)
```
```>>> abjad.Multiplier.from_dot_count(2)
Multiplier(7, 4)
```
```>>> abjad.Multiplier.from_dot_count(3)
Multiplier(15, 8)
```
```>>> abjad.Multiplier.from_dot_count(4)
Multiplier(31, 16)
```
Return type: `Multiplier`
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 `(Duration).``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 `(Duration).``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`
`(Duration).``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.

`(Duration).``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.

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

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

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

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

`(Duration).``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.

`(Duration).``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.

`(Duration).``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.

`(Duration).``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`
`(Duration).``pair`

Gets numerator and denominator.

Gets pair:

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

Returns integer pair.

`(Duration).``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.

`(Duration).``reciprocal`

Gets reciprocal.

Gets reciprocal:

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

Returns new duration.