# Offset¶

class `durationtools.``Offset`

Offset.

Initializes from integer numerator:

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

Initializes from integer numerator and denominator:

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

Initializes from integer-equivalent numeric numerator:

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

Initializes from integer-equivalent numeric numerator and denominator:

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

Initializes from integer-equivalent singleton:

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

Initializes from integer-equivalent pair:

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

Initializes from duration:

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

Initializes from other offset:

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

Initializes from other offset with grace displacement:

```>>> offset = abjad.Offset((3, 16), grace_displacement=(-1, 16))
Offset(
(3, 16),
grace_displacement=Duration(-1, 16)
)
```

Intializes from fraction:

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

Initializes from solidus string:

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

Initializes from nonreduced fraction:

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

Offsets inherit from built-in fraction:

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

Offsets are numbers:

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

## Attribute summary¶

 `conjugate` Conjugate is a no-op for Reals. `dot_count` Gets dot count. `durations_to_nonreduced_fractions`(durations) 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_decimal` Converts a finite Decimal instance to a rational number, exactly. `from_float` Converts a finite float to a rational number, exactly. `from_lilypond_duration_string`(…) Initializes duration from LilyPond duration string. `grace_displacement` Gets grace displacement. `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`(argument) Is true when argument correctly initializes a duration. `lilypond_duration_string` Gets LilyPond duration string. `limit_denominator` Closest Fraction to self with denominator at most max_denominator. `pair` Gets numerator and denominator. `prolation_string` Gets prolation string. `real` Real numbers are their real component. `reciprocal` Gets reciprocal. `to_clock_string`() Changes duration to clock string. `to_score_markup`() Changes duration to score markup. `with_denominator`(denominator) Changes duration to nonreduced fraction with denominator. `__abs__`(*arguments) Gets absolute value of duration. `__add__`(*arguments) Adds duration to arguments. `__bool__` self != 0 `__ceil__` math.ceil(a) `__complex__` complex(self) == complex(float(self), 0) `__copy__`(*arguments) Copies offset. `__deepcopy__`(*arguments) Deep copies offset. `__div__`(*arguments) Divides duration by arguments. `__divmod__`(*arguments) Equals the pair (duration // arguments, duration % arguments). `__eq__`(argument) Is true when offset equals argument. `__float__` float(self) = self.numerator / self.denominator `__floor__` math.floor(a) `__floordiv__` a // b `__format__`([format_specification]) Formats duration. `__ge__`(argument) Is true when offset is greater than or equal to argument. `__gt__`(argument) Is true when offset is greater than argument. `__hash__`() Hashes duration. `__le__`(argument) Is true when offset is less than or equal to argument. `__lt__`(argument) Is true when offset is less than argument. `__mod__`(*arguments) Modulus operator applied to duration. `__mul__`(*arguments) Duration multiplied by arguments. `__ne__`(argument) Is true when Abjad object does not equal argument. `__neg__`(*arguments) Negates duration. `__new__`(class_, *arguments, **keywords) `__pos__`(*arguments) Get positive duration. `__pow__`(*arguments) Raises duration to arguments power. `__radd__`(*arguments) Adds arguments to duration. `__rdiv__`(*arguments) Divides arguments by duration. `__rdivmod__`(*arguments) Documentation required. `__repr__`() Gets interpreter representation of offset. `__rfloordiv__` Return value//self. `__rmod__`(*arguments) Documentation required. `__rmul__`(*arguments) Multiplies arguments by duration. `__round__` round(self, ndigits) `__rpow__`(*arguments) Raises arguments to the power of duration. `__rsub__`(*arguments) Subtracts duration from arguments. `__rtruediv__`(*arguments) Documentation required. `__str__` str(self) `__sub__`(argument) Offset taken from offset returns duration: `__truediv__`(*arguments) Documentation required. `__trunc__` trunc(a)

`(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 = '{!s}\t{}'
...         string = string.format(sixteenths, dot_count)
...         print(string)
...     except AssignabilityError:
...         sixteenths = duration.with_denominator(16)
...         string = '{!s}\t{}'
...         string = string.format(sixteenths, '--')
...         print(string)
...
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('{!s}\t{!s}'.format(sixteenths, result))
...
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('{!s}\t{!s}'.format(sixteenths, result))
...
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('{!s}\t{!s}'.format(sixteenths, result))
...
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('{!s}\t{!s}'.format(sixteenths, result))
...
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('{!s}\t{}'.format(sixty_fourths, 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.

`Offset.``grace_displacement`

Gets grace displacement.

Gets grace displacement equal to none:

```>>> offset = abjad.Offset(1, 4)
>>> offset.grace_displacement is None
True
```

Gets grace displacement equal to a negative sixteenth:

```>>> offset = abjad.Offset(1, 4, grace_displacement=(-1, 16))
>>> offset.grace_displacement
Duration(-1, 16)
```

Stores zero-valued grace displacement as none:

```>>> offset = abjad.Offset(1, 4, grace_displacement=0)
>>> offset.grace_displacement is None
True
```
```>>> offset
Offset(1, 4)
```

Defaults to none.

Set to duration or none.

Returns duration or none.

`(Duration).``has_power_of_two_denominator`

Is true when duration is an integer power of two. Otherwise false.

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.

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

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.

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

`(Fraction).``real`

Real numbers are their real component.

`(Duration).``reciprocal`

Gets reciprocal.

Gets reciprocal:

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

Returns new duration.

## Methods¶

`(Fraction).``conjugate`()

Conjugate is a no-op for Reals.

`(Fraction).``from_decimal`()

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

`(Fraction).``from_float`()

Converts a finite float to a rational number, exactly.

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

`(Fraction).``limit_denominator`()

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)
```
`(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)
>>> show(note)
```

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()
>>> show(markup)
```

Changes nonassignable duration to score markup:

```>>> markup = abjad.Duration(5, 16).to_score_markup()
>>> show(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))
>>> show(staff)
```

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¶

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

Returns new object of durations type.

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

`(Duration).``is_token`(argument)

Is true when argument correctly initializes a duration. Otherwise false.

Is true when expression is a duration token:

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

Returns true or false.

## Special methods¶

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

Gets absolute value of duration.

Returns nonnegative duration.

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

self != 0

`(Fraction).``__ceil__`()

math.ceil(a)

`(Fraction).``__complex__`()

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

`Offset.``__copy__`(*arguments)

Copies offset.

```>>> import copy
```

Copies offset with grace displacement:

```>>> offset_1 = abjad.Offset((1, 4), grace_displacement=(-1, 16))
>>> offset_2 = copy.copy(offset_1)
```
```>>> offset_1
Offset(
(1, 4),
grace_displacement=Duration(-1, 16)
)
```
```>>> offset_2
Offset(
(1, 4),
grace_displacement=Duration(-1, 16)
)
```
```>>> offset_1 == offset_2
True
```
```>>> offset_1 is offset_2
False
```

Returns new offset.

`Offset.``__deepcopy__`(*arguments)

Deep copies offset.

```>>> import copy
```

Copies offset with grace displacement:

```>>> offset_1 = abjad.Offset((1, 4), grace_displacement=(-1, 16))
>>> offset_2 = copy.deepcopy(offset_1)
```
```>>> offset_1
Offset(
(1, 4),
grace_displacement=Duration(-1, 16)
)
```
```>>> offset_2
Offset(
(1, 4),
grace_displacement=Duration(-1, 16)
)
```
```>>> offset_1 == offset_2
True
```
```>>> offset_1 is offset_2
False
```

Returns new offset.

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

`Offset.``__eq__`(argument)

Is true when offset equals argument. Otherwise false.

With equal numerators, denominators and grace displacements:

```>>> offset_1 = abjad.Offset((1, 4), grace_displacement=(-1, 16))
>>> offset_2 = abjad.Offset((1, 4), grace_displacement=(-1, 16))
```
```>>> offset_1 == offset_1
True
```
```>>> offset_1 == offset_2
True
```
```>>> offset_2 == offset_1
True
```
```>>> offset_2 == offset_2
True
```

With equal numerators and denominators but differing grace displacements:

```>>> offset_1 = abjad.Offset((1, 4), grace_displacement=(-1, 8))
>>> offset_2 = abjad.Offset((1, 4), grace_displacement=(-1, 16))
```
```>>> offset_1 == offset_1
True
```
```>>> offset_1 == offset_2
False
```
```>>> offset_2 == offset_1
False
```
```>>> offset_2 == offset_2
True
```

With differing numerators and denominators. Ignores grace displacements:

```>>> offset_1 = abjad.Offset((1, 4))
>>> offset_2 = abjad.Offset((1, 2), grace_displacement=(-99))
```
```>>> offset_1 == offset_1
True
```
```>>> offset_1 == offset_2
False
```
```>>> offset_2 == offset_1
False
```
```>>> offset_2 == offset_2
True
```

Returns true or false.

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

math.floor(a)

`(Fraction).``__floordiv__`()

a // b

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

Formats duration.

Set format_specification to ‘’ or ‘storage’. Interprets ‘’ equal to ‘storage’.

Returns string.

`Offset.``__ge__`(argument)

Is true when offset is greater than or equal to argument. Otherwise false.

With equal numerators, denominators and grace displacements:

```>>> offset_1 = abjad.Offset((1, 4), grace_displacement=(-1, 16))
>>> offset_2 = abjad.Offset((1, 4), grace_displacement=(-1, 16))
```
```>>> offset_1 >= offset_1
True
```
```>>> offset_1 >= offset_2
True
```
```>>> offset_2 >= offset_1
True
```
```>>> offset_2 >= offset_2
True
```

With equal numerators and denominators but differing grace displacements:

```>>> offset_1 = abjad.Offset((1, 4), grace_displacement=(-1, 8))
>>> offset_2 = abjad.Offset((1, 4), grace_displacement=(-1, 16))
```
```>>> offset_1 >= offset_1
True
```
```>>> offset_1 >= offset_2
False
```
```>>> offset_2 >= offset_1
True
```
```>>> offset_2 >= offset_2
True
```

With differing numerators and denominators. Ignores grace displacements:

```>>> offset_1 = abjad.Offset((1, 4))
>>> offset_2 = abjad.Offset((1, 2), grace_displacement=(-99))
```
```>>> offset_1 >= offset_1
True
```
```>>> offset_1 >= offset_2
False
```
```>>> offset_2 >= offset_1
True
```
```>>> offset_2 >= offset_2
True
```

Returns true or false.

`Offset.``__gt__`(argument)

Is true when offset is greater than argument. Otherwise false.

With equal numerators, denominators and grace displacements:

```>>> offset_1 = abjad.Offset((1, 4), grace_displacement=(-1, 16))
>>> offset_2 = abjad.Offset((1, 4), grace_displacement=(-1, 16))
```
```>>> offset_1 > offset_1
False
```
```>>> offset_1 > offset_2
False
```
```>>> offset_2 > offset_1
False
```
```>>> offset_2 > offset_2
False
```

With equal numerators and denominators but differing grace displacements:

```>>> offset_1 = abjad.Offset((1, 4), grace_displacement=(-1, 8))
>>> offset_2 = abjad.Offset((1, 4), grace_displacement=(-1, 16))
```
```>>> offset_1 > offset_1
False
```
```>>> offset_1 > offset_2
False
```
```>>> offset_2 > offset_1
True
```
```>>> offset_2 > offset_2
False
```

With differing numerators and denominators. Ignores grace displacements:

```>>> offset_1 = abjad.Offset((1, 4))
>>> offset_2 = abjad.Offset((1, 2), grace_displacement=(-99))
```
```>>> offset_1 > offset_1
False
```
```>>> offset_1 > offset_2
False
```
```>>> offset_2 > offset_1
True
```
```>>> offset_2 > offset_2
False
```

Returns true or false.

`Offset.``__hash__`()

Hashes duration.

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

Returns integer.

`Offset.``__le__`(argument)

Is true when offset is less than or equal to argument. Otherwise false.

With equal numerators, denominators and grace displacements:

```>>> offset_1 = abjad.Offset((1, 4), grace_displacement=(-1, 16))
>>> offset_2 = abjad.Offset((1, 4), grace_displacement=(-1, 16))
```
```>>> offset_1 <= offset_1
True
```
```>>> offset_1 <= offset_2
True
```
```>>> offset_2 <= offset_1
True
```
```>>> offset_2 <= offset_2
True
```

With equal numerators and denominators but differing grace displacements:

```>>> offset_1 = abjad.Offset((1, 4), grace_displacement=(-1, 8))
>>> offset_2 = abjad.Offset((1, 4), grace_displacement=(-1, 16))
```
```>>> offset_1 <= offset_1
True
```
```>>> offset_1 <= offset_2
True
```
```>>> offset_2 <= offset_1
False
```
```>>> offset_2 <= offset_2
True
```

With differing numerators and denominators. Ignores grace displacements:

```>>> offset_1 = abjad.Offset((1, 4))
>>> offset_2 = abjad.Offset((1, 2), grace_displacement=(-99))
```
```>>> offset_1 <= offset_1
True
```
```>>> offset_1 <= offset_2
True
```
```>>> offset_2 <= offset_1
False
```
```>>> offset_2 <= offset_2
True
```

Returns true or false.

`Offset.``__lt__`(argument)

Is true when offset is less than argument. Otherwise false.

With equal numerators, denominators and grace displacements:

```>>> offset_1 = abjad.Offset((1, 4), grace_displacement=(-1, 16))
>>> offset_2 = abjad.Offset((1, 4), grace_displacement=(-1, 16))
```
```>>> offset_1 < offset_1
False
```
```>>> offset_1 < offset_2
False
```
```>>> offset_2 < offset_1
False
```
```>>> offset_2 < offset_2
False
```

With equal numerators and denominators but differing nonzero grace displacements:

```>>> offset_1 = abjad.Offset((1, 4), grace_displacement=(-1, 8))
>>> offset_2 = abjad.Offset((1, 4), grace_displacement=(-1, 16))
```
```>>> offset_1 < offset_1
False
```
```>>> offset_1 < offset_2
True
```
```>>> offset_2 < offset_1
False
```
```>>> offset_2 < offset_2
False
```

With equal numerators and denominators but differing zero-valued grace displacements:

```>>> offset_1 = abjad.Offset((1, 4), grace_displacement=(-1, 8))
```
```>>> offset_1 < offset_1
False
```
```>>> offset_1 < offset_2
True
```
```>>> offset_2 < offset_1
False
```
```>>> offset_2 < offset_2
False
```

With differing numerators and denominators. Ignores grace displacements:

```>>> offset_1 = abjad.Offset((1, 4))
>>> offset_2 = abjad.Offset((1, 2), grace_displacement=(-99))
```
```>>> offset_1 < offset_1
False
```
```>>> offset_1 < offset_2
True
```
```>>> offset_2 < offset_1
False
```
```>>> offset_2 < offset_2
False
```

Returns true or false.

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

Modulus operator applied to duration.

Returns duration.

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

`(AbjadObject).``__ne__`(argument)

Is true when Abjad object does not equal argument. Otherwise false.

Returns true or false.

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

Negates duration.

Returns new duration.

static `Offset.``__new__`(class_, *arguments, **keywords)
`(Duration).``__pos__`(*arguments)

Get positive duration.

Returns new duration.

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

Raises duration to arguments power.

Returns new duration.

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

Returns new duration.

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

Divides arguments by duration.

Returns new duration.

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

Documentation required.

`Offset.``__repr__`()

Gets interpreter representation of offset.

Gets interpreter representation of offset without grace displacement:

```>>> abjad.Offset(1, 4)
Offset(1, 4)
```

Gets interpreter representation of offset with grace displacement:

```>>> abjad.Offset(1, 4, grace_displacement=(-1, 16))
Offset(
(1, 4),
grace_displacement=Duration(-1, 16)
)
```
`(Fraction).``__rfloordiv__`()

Return value//self.

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

Documentation required.

`(Duration).``__rmul__`(*arguments)

Multiplies arguments by duration.

Returns new duration.

`(Fraction).``__round__`()

round(self, ndigits)

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)

`Offset.``__sub__`(argument)

Offset taken from offset returns duration:

```>>> abjad.Offset(2) - abjad.Offset(1, 2)
Duration(3, 2)
```

Duration taken from offset returns another offset:

```>>> abjad.Offset(2) - abjad.Duration(1, 2)
Offset(3, 2)
```

Coerce argument to offset when argument is neither offset nor duration:

```>>> abjad.Offset(2) - abjad.Fraction(1, 2)
Duration(3, 2)
```

Returns duration or offset.

`(Duration).``__truediv__`(*arguments)

Documentation required.

`(Fraction).``__trunc__`()

trunc(a)