def __new__(class_, *arguments):
if len(arguments) == 1:
argument = arguments[0]
if type(argument) is class_:
return argument
if isinstance(argument, mathtools.NonreducedFraction):
return Fraction.__new__(class_, *argument.pair)
try:
return Fraction.__new__(class_, *argument)
except (AttributeError, TypeError):
pass
try:
return Fraction.__new__(class_, argument)
except (AttributeError, TypeError):
pass
if (isinstance(argument, tuple) and len(argument) == 2
and mathtools.is_integer_equivalent(argument[0])
and mathtools.is_integer_equivalent(argument[1])
and not argument[1] == 0):
return Fraction.__new__(
class_,
int(argument[0]),
int(argument[1]),
)
try:
return Fraction.__new__(class_, argument.duration)
except AttributeError:
pass
if isinstance(argument, str) and '/' not in argument:
result = Duration._initialize_from_lilypond_duration_string(
argument)
return Fraction.__new__(class_, result)
if (isinstance(argument, tuple) and len(argument) == 1
and mathtools.is_integer_equivalent(argument[0])):
return Fraction.__new__(class_, int(argument[0]))
else:
try:
return Fraction.__new__(class_, *arguments)
except TypeError:
pass
if mathtools.all_are_integer_equivalent_numbers(arguments):
return Fraction.__new__(class_, *[int(x) for x in arguments])
message = 'can not construct duration: {!r}.'
message = message.format(arguments)
raise ValueError(message)
def _format_repeat_tremolo_command(self):
tremolo = inspect(self).get_indicator(indicatortools.Tremolo)
reattack_duration = self._get_tremolo_reattack_duration()
repeat_count = self.written_duration / reattack_duration / 2
if not mathtools.is_integer_equivalent(repeat_count):
message = 'can not tremolo duration {} with {} beams.'
message = message.format(self.written_duration, tremolo.beam_count)
raise Exception(message)
repeat_count = int(repeat_count)
command = r'\repeat tremolo {}'.format(repeat_count)
return command
def __init__(self, number=0):
from abjad.tools import pitchtools
if isinstance(number, numbers.Number):
sign = mathtools.sign(number)
abs_token = abs(number)
if abs_token % 12 == 0 and 12 <= abs_token:
number = 12
else:
number = abs_token % 12
number *= sign
elif isinstance(number, pitchtools.Interval):
number = number.semitones
sign = mathtools.sign(number)
abs_number = abs(number)
if abs_number % 12 == 0 and 12 <= abs_number:
number = 12
else:
number = abs_number % 12
number *= sign
elif isinstance(number, pitchtools.IntervalClass):
number = number.number
sign = mathtools.sign(number)
abs_number = abs(number)
if abs_number % 12 == 0 and 12 <= abs_number:
number = 12
else:
number = abs_number % 12
number *= sign
elif isinstance(number, str):
number = float(number)
if mathtools.is_integer_equivalent(number):
number = int(number)
sign = mathtools.sign(number)
abs_token = abs(number)
if abs_token % 12 == 0 and 12 <= abs_token:
number = 12
else:
number = abs_token % 12
number *= sign
else:
message = 'can not initialize {} from {!r}.'
message = message.format(type(self).__name__, number)
raise ValueError(message)
self._number = number
def is_integer_equivalent_n_tuple(argument, n):
r'''Is true when `argument` is a tuple of `n` integer-equivalent items.
Otherwise false.
.. container:: example
>>> tuple_ = (2.0, '3', abjad.Fraction(4, 1))
>>> abjad.mathtools.is_integer_equivalent_n_tuple(tuple_, 3)
True
>>> tuple_ = (2.5, '3', abjad.Fraction(4, 1))
>>> abjad.mathtools.is_integer_equivalent_n_tuple(tuple_, 3)
False
Returns true or false.
'''
from abjad.tools import mathtools
return (isinstance(argument, tuple) and len(argument) == n
and all(mathtools.is_integer_equivalent(_) for _ in argument))
def __init__(self, number=0):
if isinstance(number, type(self)):
number = number.number
elif isinstance(number, numbers.Number):
if not 0 <= number <= 6:
message = 'must be between 0 and 6, inclusive.'
raise ValueError(message)
elif getattr(number, 'semitones', None) is not None:
number = number.semitones
number %= 12
if 6 < number:
number = 12 - number
elif isinstance(number, str):
number = float(number)
if mathtools.is_integer_equivalent(number):
number = int(number)
else:
message = 'can not initialize {}: {!r}.'
message = message.format(type(self).__name__, number)
raise TypeError(message)
self._number = number
def all_are_integer_equivalent(argument):
'''Is true when `argument` is an iterable collection with
integer-equivalent items. Otherwise false.
.. container:: example
>>> items = [1, '2', 3.0, abjad.Fraction(4, 1)]
>>> abjad.mathtools.all_are_integer_equivalent(items)
True
>>> abjad.mathtools.all_are_integer_equivalent([1, '2', 3.5, 4])
False
Returns true or false.
'''
from abjad.tools import mathtools
try:
return all(
mathtools.is_integer_equivalent(_)
for _ in argument
)
except TypeError:
return False