rh=SSKJr SSKJr SSKJr SSKrSSKJrJr SSK r SSK r SSK J r J r SSKrSSKJr SSKJr SS KJrJr \ (aSS KJr SS KJrJrJr /S Qr/S Qr\SSrS\S'S\S'S\S'S\S'S6Sjr\R@r!\S7Sj5r"\#"/SQ5r$\ S8Sj5r%\ S9Sj5r%S:Sjr%\R@4S;Sjjr&SSjjr(S?S@Sjjr)SAS jr*S!r+SBS"jr,SCS#jr-SDS$jr.SES%jr/SFSGS&jjr0SHSIS'jjr1\"S(S)S*5SJS+j5r2SKS,jr3SLS-jr4S.S/.SMS0jjr5SNS1jr6SOSPS2jjr70r8\9"\:"\55H]r;\\;r<\\;\8\<'\;\8\>'\;\8\?"\;5\7"\;5-'\\;r@\@\<:wdMC\@R{5rA\;\8\@'\;\8\A'M_ C;"S3S4\R5rC\5\6/rD\ES5:XaSSKr\R"\C5 gg)Q) annotations)Fraction)cacheN)isclosegcd)overload TYPE_CHECKING)defaults) deprecated) OffsetQLInOffsetQL)Decimal)IterableSequence Collection)ordinals musicOrdinalsordinalsToNumbersnumToIntOrFloatopFrac mixedNumeralroundToHalfIntegeraddFloatPrecision strTrimFloatnearestMultiple dotMultiplierdecimalToTupletunitNormalizeProportionunitBoundaryProportionweightedSelectionapproximateGCDcontiguousListgroupContiguousIntegers fromRomantoRomanordinalAbbreviation)ZerothFirstSecondThirdFourthFifthSixthSeventhEighthNinthTenthEleventhTwelfth Thirteenth Fourteenth Fifteenth Sixteenth Seventeenth Eighteenth Nineteenth Twentiethz Twenty-firstz Twenty-secondUnisonOctavez Double-octavez Triple-octavec[U5n[ XSS9(aU$US-$![[4a [U5n[U5nN>f=f)a Given a number, return an integer if it is very close to an integer, otherwise, return a float. This routine is very important for conversion of :class:`~music21.pitch.Accidental` objects' `.alter` attribute in musicXML must be 1 (not 1.0) for sharp and -1 (not -1.0) for flat, but allows for 0.5 for half-sharp. >>> common.numToIntOrFloat(1.0) 1 >>> common.numToIntOrFloat(1.00003) 1.00003 >>> common.numToIntOrFloat(1.5) 1.5 >>> common.numToIntOrFloat(2) 2 >>> common.numToIntOrFloat(-5) -5 >>> common.numToIntOrFloat(1.0000000005) 1 >>> common.numToIntOrFloat(0.999999999) 1 >>> sharp = pitch.Accidental('sharp') >>> common.numToIntOrFloat(sharp.alter) 1 >>> halfFlat = pitch.Accidental('half-flat') >>> common.numToIntOrFloat(halfFlat.alter) -0.5 Can also take in a string representing an int or float >>> common.numToIntOrFloat('1.0') 1 >>> common.numToIntOrFloat('1') 1 >>> common.numToIntOrFloat('1.25') 1.25 Others raise a ValueError >>> common.numToIntOrFloat('one') Traceback (most recent call last): ValueError: could not convert string to float: 'one' Fractions also become ints or floats >>> from fractions import Fraction >>> common.numToIntOrFloat(Fraction(1, 2)) 0.5 >>> common.numToIntOrFloat(Fraction(4, 3)) 1.333333333... Note: Decimal objects are not supported. gư>abs_tol)round ValueError TypeErrorfloatr)valueintVals T/home/james-whalen/.local/lib/python3.13/site-packages/music21/common/numberTools.pyrrIsTtu vd+ 3;  "e us #&A  A cJU[::aX4$UnUnSupEpgX-nXXU--n U [:aOXgXHU--U 4upEpgXX-- pM,[U- U-n XJU--n XZU--n Un Un[X-X,-- 5nX<-n[X-X.-- 5nX>-nUU-UU-- nUS:aX4$X4$)a Used in opFrac Copied from fractions.limit_denominator. Their method requires creating three new Fraction instances to get one back. This doesn't create any call before Fraction. DENOM_LIMIT is hardcoded to defaults.limitOffsetDenominator for speed. returns a new n, d. >>> common.numberTools._preFracLimitDenominator(100001, 300001) (1, 3) >>> from fractions import Fraction >>> Fraction(100_000_000_001, 30_0000_000_001).limit_denominator(65535) Fraction(1, 3) >>> Fraction(100001, 300001).limit_denominator(65535) Fraction(1, 3) Timing differences are huge! t is timeit.timeit t('Fraction(*common.numberTools._preFracLimitDenominator(*x.as_integer_ratio()))', setup='x = 1000001/3000001; from music21 import common;from fractions import Fraction', number=100000) 1.0814228057861328 t('Fraction(x).limit_denominator(65535)', setup='x = 1000001/3000001; from fractions import Fraction', number=100000) 7.941488981246948 Nothing changed in 2023, in fact, it's faster now with the cache, and even without the cache, it's still 4x faster. Proof of working: >>> import random >>> myWay = lambda x: Fraction(*common.numberTools._preFracLimitDenominator( ... *x.as_integer_ratio())) >>> theirWay = lambda x: Fraction(x).limit_denominator(65535) >>> for _ in range(50): ... x = random.random() ... if myWay(x) != theirWay(x): ... print(f'boo: {x}, {myWay(x)}, {theirWay(x)}') (n.b. -- nothing printed) )rr=r=rr) DENOM_LIMITabs)ndnOrgdOrgp0q0p1q1aq2kbound1nbound1dbound2nbound2dbound1minusS_nbound1minusS_dbound2minusS_nbound2minusS_d differences rL_preFracLimitDenominatorrdsl Kv D DNBB  F b&[  "fb0ae)1  r b Ar6kGr6kGGG'.T^<=N^N'.T^<=N^N >1n~6UVJQ!!!!)g?g?g?g??g?????@@@@cgNnums rLrrrecgrprqrrs rLrrrtrecU[;aUS-$[U5nU[LaXUR5nUS[:a9[ [ U66nURnXDS- -S:XaURUS-- $U$U$U[LaUS-$U[ La+URnXDS- -S:XaURUS-- $U$Ucg[U[5(aUS-$[U[5(a[[U55$[U[ 5(a+URnXDS- -S:XaURUS-- $U$[SU35e)a opFrac -> optionally convert a number to a fraction or back. Important music21 function for working with offsets and quarterLengths Takes in a number and converts it to a Fraction with denominator less than limitDenominator if it is not binary expressible; otherwise return a float. Or if the Fraction can be converted back to a binary expressible float then do so. This function should be called often to ensure that values being passed around are floats and ints wherever possible and fractions where needed. The naming of this method violates music21's general rule of no abbreviations, but it is important to make it short enough so that no one will be afraid of calling it often. It also doesn't have a setting for maxDenominator so that it will expand in Code Completion easily. That is to say, this function has been set up to be used, so please use it. This is a performance-critical operation. Do not alter it in any way without running many timing tests. >>> from fractions import Fraction >>> defaults.limitOffsetDenominator 65535 >>> common.opFrac(3) 3.0 >>> common.opFrac(1/3) Fraction(1, 3) >>> common.opFrac(1/4) 0.25 >>> f = Fraction(1, 3) >>> common.opFrac(f + f + f) 1.0 >>> common.opFrac(0.99999999842) 1.0 >>> common.opFrac(0.123456789) Fraction(10, 81) >>> common.opFrac(0.000001) 0.0 Please check against None before calling, but None is changed to 0.0 >>> common.opFrac(None) 0.0 * Changed in v9.3: opFrac(None) should not be called. If it is called, it now returns 0.0 rEr=rzCannot convert num: ) _KNOWN_PASSEStyperIas_integer_ratiorNrrd _denominator _numeratorint isinstancer denominator numeratorrH)rsnumTypeirf_outrQs rLrrsft mSy3iG% ! ! # a5; 6;>QW- -J  C  Sy C  eCj!! C " " OO QKA ==AG, ,J.se455rec[U[5(dP[[U5S5up#[U5R U5nUS:a US- nSU- nO1US:XaSnUS- nO#[ [U55nX- nUS:aUS-nU(a+U(a[ U5SU3$[ [ U55$US:wa [ U5$[ S5$)a  Returns a string representing a mixedNumeral form of a number >>> common.mixedNumeral(1.333333) '1 1/3' >>> common.mixedNumeral(0.333333) '1/3' >>> common.mixedNumeral(-1.333333) '-1 1/3' >>> common.mixedNumeral(-0.333333) '-1/3' >>> common.mixedNumeral(0) '0' >>> common.mixedNumeral(-0) '0' Works with Fraction objects too >>> from fractions import Fraction >>> common.mixedNumeral(Fraction(31, 7)) '4 3/7' >>> common.mixedNumeral(Fraction(1, 5)) '1/5' >>> common.mixedNumeral(Fraction(-1, 5)) '-1/5' >>> common.mixedNumeral(Fraction(-4, 5)) '-4/5' >>> common.mixedNumeral(Fraction(-31, 7)) '-4 3/7' Denominator is limited by default but can be changed. >>> common.mixedNumeral(2.0000001) '2' >>> common.mixedNumeral(2.0000001, limitDenominator=10000000) '2 1/10000000' rir=rEr )r}rdivmodrIlimit_denominatorr|str)exprlimitDenominatorquotient remainder remainderFracs rLrrksP dH % %$U4[#6 +==>NO b= MH -M ^H)A-MuT{# a< R M (m_Am_5 5s8}% % A }% % q6Mrec[US5up[U5nUS:aSnX-$SUs=::aS:a O OSnX-$SnX-$)az Given a floating-point number, round to the nearest half-integer. Returns int or float >>> common.roundToHalfInteger(1.2) 1 >>> common.roundToHalfInteger(1.35) 1.5 >>> common.roundToHalfInteger(1.8) 2 >>> common.roundToHalfInteger(1.6234) 1.5 0.25 rounds up: >>> common.roundToHalfInteger(0.25) 0.5 as does 0.75 >>> common.roundToHalfInteger(0.75) 1 unlike python round function, does the same for 1.25 and 1.75 >>> common.roundToHalfInteger(1.25) 1.5 >>> common.roundToHalfInteger(1.75) 2 negative numbers however, round up on the boundaries >>> common.roundToHalfInteger(-0.26) -0.5 >>> common.roundToHalfInteger(-0.25) 0 rirfrrhrgr=)rr|)rsrKfloatVals rLrrscJc3'F [F$    D     rec[U[5(a [U5nSnUHn[XUS9(dM[ U5s $ U$)a Given a value that suggests a floating point fraction, like 0.33, return a Fraction or float that provides greater specification, such as Fraction(1, 3) >>> import fractions >>> common.addFloatPrecision(0.333) Fraction(1, 3) >>> common.addFloatPrecision(0.33) Fraction(1, 3) >>> common.addFloatPrecision(0.35) == fractions.Fraction(1, 3) False >>> common.addFloatPrecision(0.2) == 0.2 True >>> common.addFloatPrecision(0.125) 0.125 >>> common.addFloatPrecision(1/7) == 1/7 True )gUUUUUU?gUUUUUU?gUUUUUU?g?rC)r}rrIrr)xgrainvaluesvs rLrrsI&!S !HF  1 ' '!9  HrecS[U5-S-nX -nURS5n[U5n[US- US-S5HnX6S:wa O US- nM USUnU$)aC returns a string from a float that is at most maxNum of decimal digits long, but never less than 1. >>> common.strTrimFloat(42.3333333333) '42.3333' >>> common.strTrimFloat(42.3333333333, 2) '42.33' >>> common.strTrimFloat(6.66666666666666, 2) '6.67' >>> common.strTrimFloat(2.0) '2.0' >>> common.strTrimFloat(-5) '-5.0' z%.f.r=r0r)rindexlenrange)floatNummaxNumoffBuildStringoff offDecimaloffLenrs rLrrsx"S[(3.N  #C3J XFvz:>26 :  aZF 7 a-C JrecdUS:a[SUS3S-SU3-5e[R"X- 5nUS- nX-nXS--nX@s=:aU:aO O[SUS U35eX@s=::aXC-::a O OU[X- S 5[X- S 54$U[XP- S 5[X- S 54$) a Given a positive value `n`, return the nearest multiple of the supplied `unit` as well as the absolute difference (error) to seven significant digits and the signed difference. >>> print(common.nearestMultiple(0.25, 0.25)) (0.25, 0.0, 0.0) >>> print(common.nearestMultiple(0.35, 0.25)) (0.25, 0.1..., 0.1...) >>> print(common.nearestMultiple(0.20, 0.25)) (0.25, 0.05..., -0.05...) Note that this one also has an error of 0.1, but it's a positive error off of 0.5 >>> print(common.nearestMultiple(0.4, 0.25)) (0.5, 0.1..., -0.1...) >>> common.nearestMultiple(0.4, 0.25)[0] 0.5 >>> common.nearestMultiple(23404.001, 0.125)[0] 23404.0 >>> common.nearestMultiple(23404.134, 0.125)[0] 23404.125 Error is always positive, but signed difference can be negative. >>> common.nearestMultiple(23404 - 0.0625, 0.125) (23403.875, 0.0625, 0.0625) >>> common.nearestMultiple(0.001, 0.125)[0] 0.0 >>> from math import isclose >>> isclose(common.nearestMultiple(0.25, 1 / 3)[0], 0.33333333, abs_tol=1e-7) True >>> isclose(common.nearestMultiple(0.55, 1 / 3)[0], 0.66666666, abs_tol=1e-7) True >>> isclose(common.nearestMultiple(234.69, 1 / 3)[0], 234.6666666, abs_tol=1e-7) True >>> isclose(common.nearestMultiple(18.123, 1 / 6)[0], 18.16666666, abs_tol=1e-7) True >>> common.nearestMultiple(-0.5, 0.125) Traceback (most recent call last): ValueError: n (-0.5) is less than zero. Thus, cannot find the nearest multiple for a value less than the unit, 0.125 rzn (z) is less than zero. z3Thus, cannot find the nearest multiple for a value zless than the unit, rkr=z"cannot place n between multiples: z, )rGmathfloorrF)rPunitmulthalfUnitmatchLow matchHighs rLrrs^ 1u3qc!67PQ1$89: : ::ah DczH{Hq!I! !=hZr)UVV-,-q|Q/q|Q1GGG% q153JJJre) rirjg?g?g?g?g?g?g?cBUS:a [U$SUS--S- SU-- $)a dotMultiplier(dots) returns how long to multiply the note length of a note in order to get the note length with n dots Since dotMultiplier always returns a power of two in the denominator, the float will be exact. >>> from fractions import Fraction >>> Fraction(common.dotMultiplier(1)) Fraction(3, 2) >>> Fraction(common.dotMultiplier(2)) Fraction(7, 4) >>> Fraction(common.dotMultiplier(3)) Fraction(15, 8) >>> common.dotMultiplier(0) 1.0 ri) _DOT_LOOKUP)dotss rLrrbs3& ax4  4#: # %!t) 44reclSnSnUS::a [S5eUS:aSnSU- n[R"U5up4X- nU"U5upgUS:Xa [S5eXd-n[ [ U5[ U55nXh- nXx- nUSLa[ U5[ U54$[ U5[ U54$)a For simple decimals (usually > 1), a quick way to figure out the fraction in lowest terms that gives a valid tuplet. No it does not work really fast. No it does not return tuplets with denominators over 100. Too bad, math geeks. This is real life. :-) returns (numerator, denominator) >>> common.decimalToTuplet(1.5) (3, 2) >>> common.decimalToTuplet(1.25) (5, 4) If decNum is < 1, the denominator will be greater than the numerator: >>> common.decimalToTuplet(0.8) (4, 5) If decNum is <= 0, returns a ZeroDivisionError: >>> common.decimalToTuplet(-.02) Traceback (most recent call last): ZeroDivisionError: number must be greater than zero c[SS5HDn[XS-5H/n[XU- SS9(dM[U5[U54s s $ MF g)z Utility function. r=rgHz>rC)rr)rrr|) inner_workingrjs rLfindSimpleFraction+decimalToTuplet..findSimpleFractionsP1d^E5!),=e)TBBFCJ//-$reFrz number must be greater than zeror=Tz No such luck)ZeroDivisionErrorrmodfrGrr|) decNumr flipNumeratorunused_remainder multiplierworkingjyiymy_gcds rLrr{s4M { BCC z V#'99V#4 !G!'*HR Qw((B R#b' "F B BBR!!BR!!recSnUHnUS:a [S5eX- nM /nUHnURX!- 5 M U$)a\ Normalize values within the unit interval, where max is determined by the sum of the series. >>> common.unitNormalizeProportion([0, 3, 4]) [0.0, 0.42857142857142855, 0.5714285714285714] >>> common.unitNormalizeProportion([1, 1, 1]) [0.3333333..., 0.333333..., 0.333333...] Works fine with a mix of ints and floats: >>> common.unitNormalizeProportion([1.0, 1, 1.0]) [0.3333333..., 0.333333..., 0.333333...] On 32-bit computers this number may be inexact even for small floats. On 64-bit it works fine. This is the 32-bit output for this result. common.unitNormalizeProportion([0.2, 0.6, 0.2]) [0.20000000000000001, 0.59999999999999998, 0.20000000000000001] Negative values should be shifted to positive region first: >>> common.unitNormalizeProportion([0, -2, -8]) Traceback (most recent call last): ValueError: value members must be positive rEzvalue members must be positive)rGappend)r summationrrs rLrrsQ6I  s7=> >  D  Q]$ Krec[U5n/nSn[[U55HHnU[U5S- :wa URX3X-45 X1U- nM5URUS45 MJ U$)a+ Take a series of parts with an implied sum, and create unit-interval boundaries proportional to the series components. >>> common.unitBoundaryProportion([1, 1, 2]) [(0.0, 0.25), (0.25, 0.5), (0.5, 1.0)] >>> common.unitBoundaryProportion([9, 1, 1]) [(0.0, 0.8...), (0.8..., 0.9...), (0.9..., 1.0)] rEr=ri)rrrr)seriesrboundsrrs rLrrsu #6 *D FIs4y! CIM ! MM9$+&=> ? e $I MM9c* + " MrecUbU"5nO[R"5n[U5nSn[U5HunupgXcs=::aU:dMO MXs $ X$)a: Given a list of values and an equal-sized list of weights, return a randomly selected value using the weight. Example: sum -1 and 1 for 100 values; should be around 0 or at least between -50 and 50 (99.99999% of the time) >>> -50 < sum([common.weightedSelection([-1, 1], [1, 1]) for x in range(100)]) < 50 True r)randomr enumerate)rweightsrandomGeneratorq boundariesrlowhighs rLr r s_"   MMO'0J E' 3{ ?d??= 4 =rec P[[U55nSnUH,nXB- nU[U5- n[USUS9(dM'US- nM. U[ U5:XaU$Sn/n[ 5n UHEn /n UH)n X- n U R U 5 U RU 5 M+ UR U 5 MG /nU HPn SnUH#n U Hn[XMUS9(dMUS- n M! M% U[ U5:XdM?UR U 5 MR U(d [S5e[U5$)a| Given a list of values, find the lowest common divisor of floating point values. >>> common.approximateGCD([2.5, 10, 0.25]) 0.25 >>> common.approximateGCD([2.5, 10]) 2.5 >>> common.approximateGCD([2, 10]) 2.0 >>> common.approximateGCD([1.5, 5, 2, 7]) 0.5 >>> common.approximateGCD([2, 5, 10]) 1.0 >>> common.approximateGCD([2, 5, 10, 0.25]) 0.25 >>> common.strTrimFloat(common.approximateGCD([1/3, 2/3])) '0.3333' >>> common.strTrimFloat(common.approximateGCD([5/3, 2/3, 4])) '0.3333' >>> common.strTrimFloat(common.approximateGCD([5/3, 2/3, 5])) '0.3333' >>> common.strTrimFloat(common.approximateGCD([5/3, 2/3, 5/6, 3/6])) '0.1667' rrErCr=)rirkrlrmg@rng@g @g"@g$@g&@g(@g*@g,@g.@g0@zcannot find a common divisor) rIminr|rrsetraddrGmax)rrlowestcountrx_adjust floatingValuedivisors divisionsuniqueDivisionsrcollrQrcommonUniqueDivisionss rLr!r!s>23v; F E : 3x=0 =#u 5 5 QJE   F  HIeOA A KKN    "   D1//QJE  C N " ! ( ( + !788 $ %%rev9v10zUse math.lcm insteadc2SnSnUH nU"X#5nM U$)a1 Find the least common multiple of a list of values common.lcm([3, 4, 5]) 60 common.lcm([3, 4]) 12 common.lcm([1, 2]) 2 common.lcm([3, 6]) 6 Works with any iterable, like this set common.lcm({3, 5, 6}) 30 Deprecated in v9 since Python 3.10 is the minimum version and math.lcm works in C and is faster c4[X-5[X5-$)z( find the least common multiple of a, b )rOr)rXbs rL_lcmlcm.._lcmps 15zSY&&rer=rq) filterListrlcmValflValues rLlcmrZs','Ff& MreclUSn[S[U55HnXnX1S-:wa gUS- nM g)ad returns bool True or False if a list containing ints contains only contiguous (increasing) values requires the list to be sorted first >>> l = [3, 4, 5, 6] >>> common.contiguousList(l) True >>> l.append(8) >>> common.contiguousList(l) False Sorting matters >>> l.append(7) >>> common.contiguousList(l) False >>> common.contiguousList(sorted(l)) True rr=FT)rr)inputListOrTuple currentMaxValrnewVals rLr"r"sJ.%Q'Mq#./0!( Q& & 1 rec[U5S::aU/$/n/nUR5 SnU[U5S- :aXnURU5 XS-nXTS-:waURU5 /nU[U5S- :Xa"URU5 URU5 US- nU[U5S- :aMU$)a Given a list of integers, group contiguous values into sub lists >>> common.groupContiguousIntegers([3, 5, 6]) [[3], [5, 6]] >>> common.groupContiguousIntegers([3, 4, 6]) [[3, 4], [6]] >>> common.groupContiguousIntegers([3, 4, 6, 7]) [[3, 4], [6, 7]] >>> common.groupContiguousIntegers([3, 4, 6, 7, 20]) [[3, 4], [6, 7], [20]] >>> common.groupContiguousIntegers([3, 4, 5, 6, 7]) [[3, 4, 5, 6, 7]] >>> common.groupContiguousIntegers([3]) [[3]] >>> common.groupContiguousIntegers([3, 200]) [[3], [200]] r=rr)rsortr)srcpostgroupieeNexts rLr#r#s& 3x1}u D EHHJ A s3x!|  F QE  E> KK E C1  LL  KK  Q s3x!| " KreF) strictModerncUR5nSnSnSn/nUHnXt;dM [SU35e [[U55HnX(nXTR U5n XTR X(S-5n X:a+X;a&U(aXS-:a[SSU3-5eU S -n OX:a[S U35eUR U 5 M S n UHn X- n M U $![ a N2f=f) a" Convert a Roman numeral (upper or lower) to an int https://code.activestate.com/recipes/81611-roman-numerals/ >>> common.fromRoman('ii') 2 >>> common.fromRoman('vii') 7 Works with both IIII and IV forms: >>> common.fromRoman('MCCCCLXXXIX') 1489 >>> common.fromRoman('MCDLXXXIX') 1489 Some people consider this an error, but you see it in medieval and ancient roman documents: >>> common.fromRoman('ic') 99 unless strictModern is True >>> common.fromRoman('ic', strictModern=True) Traceback (most recent call last): ValueError: input contains an invalid subtraction element (modern interpretation): ic But things like this are never seen, and thus cause an error: >>> common.fromRoman('vx') Traceback (most recent call last): ValueError: input contains an invalid subtraction element: vx )r= d)MDCLXVI)rr2rr=z$value is not a valid roman numeral: r=rz.input contains an invalid subtraction element z(modern interpretation): rz/input contains an invalid subtraction element: r)upperrGrrr IndexErrorr) rsr inputRomansubtractionValuesnumsintsplacescrrJ nextValuerrPs rLr$r$s5NJ$ .D )D F  =CJ<PQ Q3z? # MZZ]# ZZ q5(9:;I U%?I$;$H5cU;<== " EcUKMM#  e'$(I      s$AC&,C&& C32C3c[U[5(d[S[U535eSUs=:aS:d O [ S5eSnSnSn[ [ U55H'n[XU- 5nX2UU-- nXUU--nM) U$)ac Convert a number from 1 to 3999 to a roman numeral >>> common.toRoman(2) 'II' >>> common.toRoman(7) 'VII' >>> common.toRoman(1999) 'MCMXCIX' >>> common.toRoman('hi') Traceback (most recent call last): TypeError: expected integer, got <... 'str'> >>> common.toRoman(0) Traceback (most recent call last): ValueError: Argument must be between 1 and 3999 zexpected integer, got riz#Argument must be between 1 and 3999) rrirZr(rrrr=) rCMrCDrXCrXLrIXrIVr)r}r|rHrxrGrr)rsrrresultrrs rLr%r%s& c3  0c <== s>T>>?? AD RD F 3t9 Cq'M"q'E/! Aw MrecUS-nUS;aSnO4US-nUS:XaSnO&US;aSnOUS:XaS nOUS :XaS nO [S 5eUS:wa U(aUS - nU$)z Return the ordinal abbreviations for integers >>> common.ordinalAbbreviation(3) 'rd' >>> common.ordinalAbbreviation(255) 'th' >>> common.ordinalAbbreviation(255, plural=True) 'ths' r) thrr=st)rrrrr?rrndrdzSomething really weirds)rG)rJpluralvalueHundredthsrvalueMods rLr&r&9sxckO,&2: q=D . .D ]D ]D56 6 t|   Krec0\rSrSrSrSrSrSrSrSr g) Testijz" Tests not requiring file output. cgrprqselfs rLsetUp Test.setUpos recPSH upURU[U55 M" g)N))r=r)r!III)rr) assertEqualr%)r+rdsts rL testToRomanTest.testToRomanrs"8HC   S'#, /9recUR[SS5 UR[SS5 UR[SS5 UR[SS5 UR[SS5 UR[SS5 UR[S S5 UR[S S5 UR[S S5 UR[S S5 g) Nunisonr=r<firstr(1stoctaver?r>eighthr/8th)r0rr*s rLtestOrdinalsToNumbersTest.testOrdinalsToNumbersvs *84a8 *84a8 *73Q7 *73Q7 *5115 *84a8 *84a8 *84a8 *84a8 *5115rec[S5HNnSn[S5HnU[SS/SS/5- nM URSUs=:=(a S:Os 5 MP [S5HNnSn[S5HnU[SS/SS/5- nM URSUs=:*=(a S :Os 5 MP [S5HNnSn[S5HnU[SS/SS/5- nM URS Us=:*=(a S:*Os 5 MP [S5H<nSn[S5HnU[SS/SS/5- nM URUS5 M> g) Nrrrrr=ii'r )rr assertTruer0)r+rrrunused_js rLtestWeightedSelectionTest.testWeightedSelectionsQrAA4[&AwA77! OOD1NNsN + rAA4[&1vqz::! OOAKKRK ( rAA4[&1v5z::! OOC1,,, - b HA4[&1v1v66!   Q " "rerqN) __name__ __module__ __qualname____firstlineno____doc__r,r2r;rB__static_attributes__rqrerLr(r(js 0 6!#rer(__main__)rJr returnz int | float)rPr|rQr|rKtuple[int, int])rsr|rKrI)rsfloat | FractionrKrM)rsr rKr )rz numbers.Real)rs float | intrKrN)g{Gz?)rKrM)r)rrIrr|rKr)rPrIrrIrKztuple[float, float, float])rr|rKrI)rrIrKrL)rSequence[int | float]rKz list[float])rrOrKzlist[tuple[int | float, float]]rp)r list[int]rzlist[int | float]rKr|)g-C6?)rz"Collection[int | float | Fraction]rrIrKrI)rz Iterable[int]rKr|)rKbool)rrPrKzlist[list[int]])rsrrKr|)rsr|rKr)F)rJr|rKr)G __future__r fractionsr functoolsrrrrnumbersrtypingrr unittestmusic21r music21.commonr music21.common.typesr r decimalrcollections.abcrrr__all__rrrlimitOffsetDenominatorrNrd frozensetrwrrrrrrrrrrrr r!rr"r#r$r%r&rrr ordinal_index ordinalNamelowerordinalNameLowerrmusicOrdinalNamemusicOrdinalNameLowerTestCaser( _DOC_ORDERrDmainTestrqrerLris#  *%5>> ,   a a# b# bCL-- Q"Q"p     p6h#+"A"A?D-` <}+MMN$]3;& 0 6 6 8.;*+3@/0*9#8  9#| !  z Tre