3j BUdZddlmZddlmZddlZddlZddlZddlZddl Z ddl m Z ddl m Z ddl mZddlmZdd lmZdd l mZdd l mZe j*rdd l mZdd l mZddl mZej2dZdZded<Gddej:Zej>dej@dejBdiZ"gdZ#dZ$dWdZ%Gddej:Z&e&jNe&jPe&jRe&jTe&jVe&jXe&jZe&j\e&j^g Z0dZ1e&jNe&jPe&jRe&jTe&jde&jfe&jXe&jZe&j\e&j^g Z4dZ5ddddd d!d"d#Z6e&jVZ7e&jdZ8e&jfZ9e7d$fe8dfe9dfe8d%fe9d%fe7dfe&jTdfe7dfe8d&fe9d&fe8d fe9d fg Z:[7[8[9Gd'd(ejvZ< dXd)Z=d*Z>dYd+Z?dZd,Z@d[d-ZA d\d.ZBd]d/ZCiZDd0ed1<d^d3ZEGd4d5e jZGGd6d7eGZHGd8d9eGZIGd:d;eGZJ d_d<ZK d`d=ZL dad>ZM dbd?ZN dcd@ZO dddAZPGdBd2eGZQe dedCZRe dfdDZR dgdEZRe dedFZSe dfdGZS dgdHZSe dedIZTe dfdJZT dgdKZTe dedLZUe dfdMZU dgdNZUdOdP dhdQZV didRZWdjdSZXdTZYdUZZeMeOePeQgZ[e\dVk(rddl Z e jyy)kz This module defines various types of interval objects. Fundamental classes are :class:`~music21.interval.Interval`, :class:`~music21.interval.GenericInterval`, and :class:`~music21.interval.ChromaticInterval`. ) annotations)FractionN)overload)base)common) cacheMethod)StepName) environment) exceptions21)keynotepitchinterval)CDEFGABztuple[StepName, ...] STEPNAMESceZdZdZdZdZy) DirectionrN)__name__ __module__ __qualname__ DESCENDINGOBLIQUE ASCENDING=/DATA/.local/lib/python3.12/site-packages/music21/interval.pyrr3sJGIr%r DescendingOblique Ascending) ERRORPerfectMajorMinor Augmented DiminishedzDoubly-AugmentedzDoubly-DiminishedzTriply-AugmentedzTriply-DiminishedzQuadruply-AugmentedzQuadruply-Diminished) r*PMmrdAAddAAAdddAAAAddddct|dr t|drt|drt|dstd|d|dyy)zR Raise a ValueError if note1 and note2 are not both Notes or both Pitches rznote1 z and note2 z must both be notes or pitchesN)hasattr ValueErrornote1note2s r& _same_classr@KsN  )@w'w0G6%+eY>\]^^1H'r%cleZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z d Zdd ZdZedZdZdZdZy) Specifiera0 An enumeration for "specifiers" such as Major, Minor, etc. that has some special properties. >>> from music21.interval import Specifier >>> Specifier.PERFECT Value numbers are arbitrary and just there for backwards compatibility with pre v6 work: >>> Specifier.PERFECT.value 1 >>> Specifier.PERFECT.name 'PERFECT' >>> str(Specifier.PERFECT) 'P' >>> str(Specifier.MINOR) 'm' >>> str(Specifier.DBLDIM) 'dd' >>> Specifier.DBLDIM.niceName 'Doubly-Diminished' r cLttt|jSN)str prefixSpecsintvalueselfs r&__str__zSpecifier.__str__zs;s4::/00r%c"d|jdS)Nz namerSs r&__repr__zSpecifier.__repr__sTYYKq))r%c:tt|jSrN) niceSpecNamesrQrRrSs r&niceNamezSpecifier.niceNamesS_--r%cPt|j}gd}t||S)a4 Return a new specifier that inverts this Specifier. >>> interval.Specifier.MAJOR.inversion() >>> interval.Specifier.DIMINISHED.inversion() >>> interval.Specifier.PERFECT.inversion() ) NrrDrCrFrErHrGrJrIrLrK)rQrRrB)rTv inversionss r& inversionzSpecifier.inversions%  O> A''r%c xddddddddd d } |t|S#t$r}t|d |d }~wwxYw) a Returns the number of semitones this specifier is above PERFECT >>> Specifier = interval.Specifier Augmented and Doubly-Augmented intervals are one and two semitones above perfect, respectively: >>> Specifier.AUGMENTED.semitonesAbovePerfect() 1 >>> Specifier.DBLAUG.semitonesAbovePerfect() 2 Diminished intervals are negative numbers of semitones above perfect: >>> Specifier.DIMINISHED.semitonesAbovePerfect() -1 >>> Specifier.TRPDIM.semitonesAbovePerfect() -3 Perfect is 0: >>> Specifier.PERFECT.semitonesAbovePerfect() 0 Major and minor cannot be compared to Perfect, so they raise an IntervalException >>> Specifier.MINOR.semitonesAbovePerfect() Traceback (most recent call last): music21.interval.IntervalException: cannot be compared to Perfect rrrCrDrEr) r0rr4r6r8r3r5r7r9z cannot be compared to PerfectNrOKeyErrorIntervalException)rTsemitonesAdjustPerfectkes r&semitonesAbovePerfectzSpecifier.semitonesAbovePerfectseF "  W)#d)4 4 W#th.L$MNTV V Ws  949c zddddddddd d d } |t|S#t$r}t|d |d }~wwxYw)a Returns the number of semitones this specifier is above Major >>> Specifier = interval.Specifier Augmented and Doubly-Augmented intervals are one and two semitones above major, respectively: >>> Specifier.AUGMENTED.semitonesAboveMajor() 1 >>> Specifier.DBLAUG.semitonesAboveMajor() 2 Minor is below major, so it returns -1. >>> Specifier.MINOR.semitonesAboveMajor() -1 Diminished intervals are below minor: >>> Specifier.DIMINISHED.semitonesAboveMajor() -2 >>> Specifier.DBLDIM.semitonesAboveMajor() -3 Major is 0: >>> Specifier.MAJOR.semitonesAboveMajor() 0 Perfect cannot be compared to Major, so it raises an IntervalException >>> Specifier.PERFECT.semitonesAboveMajor() Traceback (most recent call last): music21.interval.IntervalException: cannot be compared to Major rrrrCrDrErcrdre) r1r2rr4r6r8r3r5r7r9z cannot be compared to MajorNrf)rTsemitonesAdjustImperfrjs r&semitonesAboveMajorzSpecifier.semitonesAboveMajorshP !  U(T3 3 U#th.J$KLRT T Us  :5:NreturnrO)rrr __doc__PERFECTMAJORMINOR AUGMENTED DIMINISHEDDBLAUGDBLDIMTRPAUGTRPDIMQUADAUGQUADDIMrUrZpropertyr]rarkror$r%r&rBrBTsp2G E EIJ F F F FGG1 *..( 0Wd6Ur%rBrErFrCrHrJrL)rrCrDrErFrGrHrrDrGc eZdZy)rhN)rrr r$r%r&rhrh>sr%rhct|dr$d|jvrtjd|Stjd|}|jj |ur||j_|jS)a utility function to return either the object itself or the `.pitch` if it's a Note. >>> p = pitch.Pitch('D#4') >>> interval._extractPitch(p) is p True >>> nEflat = note.Note('E-4') >>> interval._extractPitch(nEflat) is nEflat.pitch True If given a Note, also sets the client of the Pitch to be the Note if not already done (for safety, since the Note will be discarded.) classesPitchzmusic21.pitch.Pitchzmusic21.note.Note)r;rtcastr_client)nOrPns r& _extractPitchrDs`"tYGt||$;vv+T22 "D)Awwa 77Nr%c,|dk(ry|dkDr|dzS|dz S)am Returns an integer of the generic interval number (P5 = 5, M3 = 3, minor 3 = 3 also) etc. from the given staff distance. >>> interval.convertStaffDistanceToInterval(3) 4 >>> interval.convertStaffDistanceToInterval(7) 8 >>> interval.convertStaffDistanceToInterval(0) 1 >>> interval.convertStaffDistanceToInterval(-1) -2 rrr$) staffDists r&convertStaffDistanceToIntervalr]s)A~ Q1}1}r%c|dk(ry|dkDr't|dz dz }|dz |dzz }t||fSt|dz }|dz |dzz }t||dz fS)u Convert a diatonic number to a step name (without accidental) and an octave integer. The lowest C on a Bösendorfer Imperial Grand is assigned 1 the D above it is 2, E is 3, etc. See pitch.diatonicNoteNum for more details >>> interval.convertDiatonicNumberToStep(15) ('C', 2) >>> interval.convertDiatonicNumberToStep(23) ('D', 3) >>> interval.convertDiatonicNumberToStep(0) ('B', -1) >>> interval.convertDiatonicNumberToStep(1) ('C', 0) Extremely high and absurdly low numbers also produce "notes". >>> interval.convertDiatonicNumberToStep(2100) ('B', 299) >>> interval.convertDiatonicNumberToStep(-19) ('D', -3) OMIT_FROM_DOCS >>> interval.convertDiatonicNumberToStep(2) ('D', 0) >>> interval.convertDiatonicNumberToStep(3) ('E', 0) >>> interval.convertDiatonicNumberToStep(4) ('F', 0) >>> interval.convertDiatonicNumberToStep(5) ('G', 0) >>> interval.convertDiatonicNumberToStep(-1) ('A', -1) >>> interval.convertDiatonicNumberToStep(-2) ('G', -1) >>> interval.convertDiatonicNumberToStep(-6) ('C', -1) >>> interval.convertDiatonicNumberToStep(-7) ('B', -2) r)rrrg@rH)rQr)dnoctave stepNumbers r&convertDiatonicNumberToSteprss}T Qw ab1f^$1f!, $f,,R!V1f!, $vz22r%c t|tr|St|tr t|St|tst d|d|t vrtt j |S|jt ddDcgc]}|jc}vrHtt D]6\}}| |j|jk(s+t|cS|jtddDcgc]}|jc}vrStdttD]7}|jt|jk(s,t|cStd|cc}wcc}w)a Given an integer or a string representing a "specifier" (major, minor, perfect, diminished, etc.), return the Specifier. >>> interval.parseSpecifier('p') >>> interval.parseSpecifier('P') >>> interval.parseSpecifier('M') >>> interval.parseSpecifier('major') >>> interval.parseSpecifier('m') >>> interval.parseSpecifier('Augmented') >>> interval.parseSpecifier('a') This is not very useful, but they are there for completeness: >>> interval.parseSpecifier(interval.Specifier.MAJOR) This is the same as calling a Specifier by value: >>> interval.parseSpecifier(3) Why? Because of this: >>> interval.Specifier.MINOR.value 3 Unparsable strings raise an IntervalException: >>> interval.parseSpecifier('Zebra') Traceback (most recent call last): music21.interval.IntervalException: Cannot find a match for value: 'Zebra' Illegal intervals raise a ValueError: >>> interval.parseSpecifier(None) Traceback (most recent call last): ValueError: Value None must be int, str, or Specifier zValue z must be int, str, or SpecifierrNzCannot find a match for value: ) isinstancerBrQrOr<rPindexlower enumerater\rangelenrh)rRxiprefixs r&parseSpecifierrsS^%# % eS !6%*IJKK **5122 {{}KO,=q,=>>q#m,-A{{} a 0 6 6 88 |#. =eYG HH=?s F F cpt|tr|}tj}n t|tr|j j }tj}tjtjfD]S}t|j |vs|}|jt|j dj }U|tjjvrtjj|}ntd|dtd|d||z}|S)a Convert an interval specified in terms of its name (second, third) into an integer. If integers are passed, assume they are correct. >>> interval.convertGeneric(3) 3 >>> interval.convertGeneric('third') 3 >>> interval.convertGeneric('3rd') 3 >>> interval.convertGeneric('octave') 8 >>> interval.convertGeneric('twelfth') 12 >>> interval.convertGeneric('descending twelfth') -12 >>> interval.convertGeneric(12) 12 >>> interval.convertGeneric(-12) -12 >>> interval.convertGeneric(1) 1 >>> interval.convertGeneric(None) Traceback (most recent call last): music21.interval.IntervalException: Cannot get a direction from None. Strings are not the same as numbers: >>> interval.convertGeneric('1') Traceback (most recent call last): music21.interval.IntervalException: Cannot convert '1' to an interval. But this works: >>> interval.convertGeneric('1st') 1 zCannot convert z to an interval.zCannot get a direction from .)rrQrr#rOstriprr!directionTermsreplacer numberToolsordinalsToNumbersrh)rRpostdirectionScalar directions r&convertGenericrs P%#-- E3  ##%$--#.. 0C0CDIi(..0E9"+ nY&?&E&E&GLRRTE F&&88 8%%77>D#oeY>N$OP P">ugQ GHH / !D Kr%c|dkrd}nd}t|d\}}|dz}|dkDr |dz }|dz }t|}t|dz}t|dz}t|\}}|||dzz|z|fS) a. Given a number of semitones (positive or negative), return a default diatonic specifier and cent offset. >>> interval.convertSemitoneToSpecifierGenericMicrotone(2.5) (, 2, 50.0) >>> interval.convertSemitoneToSpecifierGenericMicrotone(-2.5) (, -3, 50.0) >>> interval.convertSemitoneToSpecifierGenericMicrotone(-2.25) (, -2, -25.0) >>> interval.convertSemitoneToSpecifierGenericMicrotone(-1.0) (, -2, 0.0) >>> interval.convertSemitoneToSpecifierGenericMicrotone(2.25) (, 2, 25.0) >>> interval.convertSemitoneToSpecifierGenericMicrotone(1.0) (, 2, 0.0) >>> interval.convertSemitoneToSpecifierGenericMicrotone(1.75) (, 2, -25.0) >>> interval.convertSemitoneToSpecifierGenericMicrotone(1.9) (, 2, -10.0...) >>> interval.convertSemitoneToSpecifierGenericMicrotone(0.25) (, 1, 25.0) >>> interval.convertSemitoneToSpecifierGenericMicrotone(12.25) (, 8, 25.0) >>> interval.convertSemitoneToSpecifierGenericMicrotone(24.25) (, 15, 25.0) >>> interval.convertSemitoneToSpecifierGenericMicrotone(23.75) (, 15, -25.0) rrrY@2d rH)divmodrQabsSEMITONES_TO_SPEC_GENERIC)countdirScalemicrocentssizerspecgenerics r&*convertSemitoneToSpecifierGenericMicrotoner1s@ qy%#LE5 EME rz    JE u:?D Z2 F-d3MD' 7fqj)X5u ==r%c(t|\}}}||fS)a Given a number of semitones, return a default diatonic specifier, and a number that can be used as a GenericInterval >>> interval.convertSemitoneToSpecifierGeneric(0) (, 1) >>> interval.convertSemitoneToSpecifierGeneric(-2) (, -2) >>> interval.convertSemitoneToSpecifierGeneric(1) (, 2) >>> interval.convertSemitoneToSpecifierGeneric(7) (, 5) >>> interval.convertSemitoneToSpecifierGeneric(11) (, 7) >>> interval.convertSemitoneToSpecifierGeneric(12) (, 8) >>> interval.convertSemitoneToSpecifierGeneric(13) (, 9) >>> interval.convertSemitoneToSpecifierGeneric(-15) (, -10) >>> interval.convertSemitoneToSpecifierGeneric(24) (, 15) Note that the tritone is given as diminished fifth, not augmented fourth: >>> interval.convertSemitoneToSpecifierGeneric(6) (, 5) Microtones are rounded here: >>> interval.convertSemitoneToSpecifierGeneric(0.4) (, 1) >>> interval.convertSemitoneToSpecifierGeneric(0.6) (, 2) )r)r specifier semitonesunused_cent_offsets r&!convertSemitoneToSpecifierGenericrfs$J0ZZ_/`,Iy, y !!r%z'dict[str, tuple[pitch.Pitch, Fraction]]_pythagorean_cacheIntervalcdddlm}|d}|j|}|jtvrt|j\}}n|}|}t dD]|}|j|jk(rt dd|z}|}n_|j|jk(rt dd|z}|}n3|jd}|jd}~td |d ||ft|j<t|j|jz d z } |t dd | zzS) a Returns the interval ratio in pythagorean tuning, always as a Fraction object. >>> iList = [interval.Interval(name) for name in ('P4', 'P5', 'M7', 'm23')] >>> iList [, , , ] >>> [interval.intervalToPythagoreanRatio(i) for i in iList] [Fraction(4, 3), Fraction(3, 2), Fraction(243, 128), Fraction(2048, 243)] Throws an exception if no ratio can be found, such as for quarter tones. >>> p1, p2 = pitch.Pitch('C1'), pitch.Pitch('C1') >>> p2.accidental = 'half-sharp' >>> fiftyCent = interval.Interval(p1, p2) >>> fiftyCent >>> interval.intervalToPythagoreanRatio(fiftyCent) Traceback (most recent call last): music21.interval.IntervalException: Could not find a pythagorean ratio for . r)rC1%rDrCP5z-P5z'Could not find a pythagorean ratio for rrr) music21.pitchr transposerYrrrrhrQps) intervalObjr start_pitchend_pitch_wanted end_pitchratio end_pitch_upend_pitch_downcounteroctavess r&intervalToPythagoreanRatiorsK8$+K",,[9  22-.>.C.CD 5# $RyG  $4$9$99 A'1( $$(8(=(== A'1*  ,55d; !/!9!9%!@!$9+aHJ J5>u4D+001#&&5;W, ,,r%cneZdZdZddZej dd d dZej dZy) IntervalBasez- General base class for inheritance. ct|j|j}tj|}||_|S)aV Uses self.transposePitch to do the same to a note. >>> n1 = note.Note('C#4', quarterLength=2.0) >>> i = interval.Interval('d5') >>> n2 = i.transposeNote(n1) >>> n2 >>> n2.pitch >>> n2.duration.type 'half' )transposePitchrcopydeepcopy)rTr>newPitchnewNotes r& transposeNotezIntervalBase.transposeNotes2&&u{{3--&  r%FinPlacectzq IntervalBase does not know how to do this, so it must be overridden in derived classes. NotImplementedError)rTpitch1rs r&rzIntervalBase.transposePitchs "!r%ctrrrSs r&reversezIntervalBase.reverses "!r%N)r> note.Noterqr)r pitch.Pitchrbool) rrr rrrabcabstractmethodrrr$r%r&rrsW& (-"*"!%"" ""r%rcheZdZdZ d& d'fd ZdZdZdZed(dZ e jd)dZ ed(dZ e jd)d Z ed(d Z ed*d Z ed+d Zed+d Zed+dZed+dZed,dZed(dZed(dZed(dZed(dZed(dZed(dZed+dZd-dZed.dZed.dZed.dZed(dZed(dZed(dZ e!d/dZ"d/d Z#d!d"d0d#Z$ d1d!d" d2d$Z%d3d%Z&xZ'S)4GenericIntervalav A GenericInterval is an interval such as Third, Seventh, Octave, or Tenth. Constructor takes an integer or string specifying the interval and direction. The interval is not specified in half-steps, but in numeric values derived from interval names: a Third is 3; a Seventh is 7, etc. String values for interval names ('3rd' or 'third') are generally accepted, but discouraged since not every one will work. staffDistance: the number of lines or spaces apart, eg: E.g. C4 to C4 = 0; C4 to D4 = 1; C4 to B3 = -1 Two generic intervals are the equal if their size and direction are the same. >>> gi = interval.GenericInterval(8) >>> gi >>> third = interval.GenericInterval(3) >>> third.directed 3 >>> third.direction >>> third.perfectable False >>> third.staffDistance 2 We can also specify intervals from strings: >>> third = interval.GenericInterval('Third') >>> third >>> third.directed 3 or like this: >>> thirdDown = interval.GenericInterval('Descending Third') >>> thirdDown >>> thirdDown.directed -3 A lot of tools for working with large intervals >>> twelfthDown = interval.GenericInterval(-12) >>> twelfthDown.niceName 'Twelfth' >>> twelfthDown.perfectable True >>> twelfthDown.staffDistance -11 >>> twelfthDown.mod7 4 >>> twelfthDown.directed -12 >>> twelfthDown.undirected 12 >>> complement12 = twelfthDown.complement() >>> complement12.niceName 'Fourth' >>> complement12.staffDistance 3 Note this illegal interval: >>> zeroth = interval.GenericInterval(0) Traceback (most recent call last): music21.interval.IntervalException: The Zeroth is not an interval However, this is okay: >>> descendingUnison = interval.GenericInterval(-1) >>> descendingUnison.direction >>> descendingUnison.directed -1 >>> descendingUnison.undirected 1 This is because we don't yet know what type of unison this is: is it a Perfect Unison or an Augmented Unison (or Augmented Prime as some prefer)? Thus, the illegal check will be moved to a higher level Interval object. A second is a step: >>> second = interval.GenericInterval(2) >>> second.isDiatonicStep True >>> second.isStep True A third is not: >>> third = interval.GenericInterval(-3) >>> third.isDiatonicStep False >>> third.isStep False Intervals more than three octaves use numbers with abbreviations instead of names >>> threeOctaveSecond = interval.GenericInterval(23) >>> threeOctaveSecond.niceName '23rd' >>> threeOctaveThird = interval.GenericInterval(24) >>> threeOctaveThird.niceName '24th' >>> threeOctaveThird.isDiatonicStep False >>> threeOctaveThird.isStep False >>> threeOctaveThird.simpleNiceName 'Third' * Changed in v6: large intervals get abbreviations. c Rt|di|d|_t||_y)Nrr$)super__init___valuerrR)rTrRkeywords __class__s r&rzGenericInterval.__init__~s( $8$ #E* r%c,t|jSrNrOdirectedrSs r& _reprInternalzGenericInterval._reprInternal4==!!r%cdt|t|sy|j|jk(ryy)a True if value and direction are the same. >>> a = interval.GenericInterval('Third') >>> b = interval.GenericInterval(-3) >>> c = interval.GenericInterval(3) >>> d = interval.GenericInterval(6) >>> a == b False >>> a == a == c True >>> b == c False >>> a != d True >>> a in [b, c, d] True >>> a == '' False >>> a is None False FT)rtyperRrTothers r&__eq__zGenericInterval.__eq__s+0%d, ZZ5;; &r%ct|dz SNrEidrSs r&__hash__zGenericInterval.__hash__$x1}r%c|jS)z The size of this interval as an integer. Synonym for `self.directed` >>> interval.GenericInterval('Descending Sixth').value -6 )rrSs r&rRzGenericInterval.values{{r%cR|j|dk(r td||_y)NrzThe Zeroth is not an interval) clearCacherhrrTnewValues r&rRzGenericInterval.values&  q=#$CD D r%c|jS)z Synonym for `self.value` >>> sixthDown = interval.GenericInterval(-6) >>> sixthDown.directed -6 >>> sixthDown.directed = 2 >>> sixthDown.value 2 rRrSs r&rzGenericInterval.directedszzr%c||_yrNrrs r&rzGenericInterval.directeds  r%c,t|jS)z Returns the absolute value of `self.directed`. Read-only >>> sixthDown = interval.GenericInterval(-6) >>> sixthDown.undirected 6 )rrRrSs r& undirectedzGenericInterval.undirecteds4::r%c|j}|dk(rtjS|dkrtjStjS)ah Returns a Direction Enum value for the direction of this interval: >>> interval.GenericInterval('Descending Fifth').direction >>> interval.GenericInterval('Unison').direction >>> interval.GenericInterval(4).direction rr)rrr"r!r#)rTr3s r&rzGenericInterval.directions? MM 6$$ $ U'' '&& &r%c |jdkDS)aW Returns True if the undirected interval is bigger than a second. >>> interval.GenericInterval('Octave').isSkip True >>> interval.GenericInterval('Descending 2nd').isSkip False >>> interval.GenericInterval(1).isSkip False Note that Unisons are neither steps nor skips. rCrrSs r&isSkipzGenericInterval.isSkips""r%c |jdk(S)a Return True if this interval is a step (a second). A synonym for `isStep` for generic intervals. >>> interval.GenericInterval(-2).isDiatonicStep True >>> interval.GenericInterval(1).isDiatonicStep False >>> interval.GenericInterval(9).isDiatonicStep False Note that Unisons are neither steps nor skips. rCr rSs r&isDiatonicStepzGenericInterval.isDiatonicSteps!##r%c|jS)a: Return True if this interval is a step (a second). A synonym for `isDiatonicStep` for generic intervals. >>> interval.GenericInterval(2).isStep True >>> interval.GenericInterval(1).isStep False >>> interval.GenericInterval(-9).isStep False )rrSs r&isStepzGenericInterval.isSteps"""r%c |jdk(S)zt Returns True if this interval is a Unison. Note that Unisons are neither steps nor skips. rr rSs r&isUnisonzGenericInterval.isUnisons!##r%cTt|jd\}}|dk(r|dz}d}||fS)zF Returns simpleUndirectedSteps and undirectedOctaves. rHrr)rr)rTrstepss r&_simpleStepsAndOctavesz&GenericInterval._simpleStepsAndOctaves's7  3 A: qLGEg~r%c |jdS)z Return the undirected distance within an octave >>> interval.GenericInterval('Descending Ninth').simpleUndirected 2 >>> interval.GenericInterval(8).simpleUndirected 1 rrrSs r&simpleUndirectedz GenericInterval.simpleUndirected3s**1--r%cH|j}|jdk\r|dk(ry|S)a Same as simpleUndirected, but allows octaves and double octaves, etc. to remain 8, which is useful for a number of parallel octave vs. unison routines. >>> interval.GenericInterval('Descending Ninth').semiSimpleUndirected 2 >>> interval.GenericInterval(8).semiSimpleUndirected 8 >>> interval.GenericInterval(-15).semiSimpleUndirected 8 rrI)rundirectedOctavesrTrs r&semiSimpleUndirectedz$GenericInterval.semiSimpleUndirected?s/ 00  ! !Q &+;q+@# #r%c |jdS)aw Returns the number of octaves (without direction) for an interval >>> interval.GenericInterval(5).undirectedOctaves 0 >>> interval.GenericInterval('Descending Ninth').undirectedOctaves 1 >>> interval.GenericInterval(8).undirectedOctaves 1 >>> interval.GenericInterval(-15).undirectedOctaves 2 rrrSs r&rz!GenericInterval.undirectedOctavesSs**1--r%cb|j}|jtjk(rd|zS|S)a< Return the number of octaves with direction. >>> interval.GenericInterval(5).octaves 0 >>> interval.GenericInterval('Descending Ninth').octaves -1 >>> interval.GenericInterval(8).octaves 1 >>> interval.GenericInterval(-15).octaves -2 r)rrrr!)rTrs r&rzGenericInterval.octavescs4!22 >>Y11 1)) )$ $r%cl|j}|jtjk(r |dkDrd|zS|S)a Return the directed distance within an octave >>> interval.GenericInterval('Descending Ninth').simpleDirected -2 >>> interval.GenericInterval(8).simpleDirected 1 >>> interval.GenericInterval(-8).simpleDirected 1 rr)rrrr!rs r&simpleDirectedzGenericInterval.simpleDirectedws< 00 >>Y11 16F6J(( (# #r%cl|j}|jtjk(r |dkDrd|zS|S)a Return the same as semiSimpleUndirected but with descending intervals as a negative number >>> interval.GenericInterval('Descending Ninth').semiSimpleDirected -2 >>> interval.GenericInterval(8).semiSimpleDirected 8 >>> interval.GenericInterval(-15).semiSimpleDirected -8 >>> interval.GenericInterval(-8).semiSimpleDirected -8 rr)rrrr!)rTrs r&semiSimpleDirectedz"GenericInterval.semiSimpleDirecteds< $88 >>Y11 16JQ6N,, ,' 'r%c|jdvS)aU Returns True if the interval might represent a perfect interval, that is, it is a Generic 4th, 5th, or unison/octave >>> interval.GenericInterval(4).perfectable True >>> interval.GenericInterval(-12).perfectable True >>> interval.GenericInterval(3).perfectable False )rrErF)rrSs r& perfectablezGenericInterval.perfectables$$ 11r%c tjj|S#t$r.t |tjj |zcYSwxYwrN)rr musicOrdinals IndexErrorrOordinalAbbreviation)rTkeyVals r& _nameFromIntzGenericInterval._nameFromIntsP P%%33F; ; Pv;!3!3!G!G!OO O Ps4AAc8|j|jS)a Return the niceName as a string for this Interval >>> interval.GenericInterval(4).niceName 'Fourth' >>> interval.GenericInterval(-12).niceName 'Twelfth' >>> interval.GenericInterval(3).niceName 'Third' Extremely large intervals get displayed as abbreviations >>> interval.GenericInterval(44).niceName '44th' * Changed in v6: large numbers get the 'th' or 'rd' etc. suffix. )r*rrSs r&r]zGenericInterval.niceNames&  11r%c8|j|jS)a+ Return the niceName as a string for this Interval's simple form >>> interval.GenericInterval(4).simpleNiceName 'Fourth' >>> interval.GenericInterval(-12).simpleNiceName 'Fifth' >>> interval.GenericInterval(8).simpleNiceName 'Unison' )r*rrSs r&simpleNiceNamezGenericInterval.simpleNiceNames  !6!677r%c8|j|jS)a; Return the niceName as a string for this Interval's semiSimple form >>> interval.GenericInterval(4).semiSimpleNiceName 'Fourth' >>> interval.GenericInterval(-12).semiSimpleNiceName 'Fifth' >>> interval.GenericInterval(8).semiSimpleNiceName 'Octave' )r*rrSs r&semiSimpleNiceNamez"GenericInterval.semiSimpleNiceNames  !:!:;;r%c8|j}|dkDr|dz S|dzS)a Return the number of spaces/stafflines that this interval represents. A unison is 0, an ascending second is 1, a descending third is -2, etc. Useful for interval arithmetic >>> interval.GenericInterval('Ascending Third').staffDistance 2 >>> interval.GenericInterval(-8).staffDistance -7 >>> interval.GenericInterval(1).staffDistance 0 rr)r)rTrs r& staffDistancezGenericInterval.staffDistances( == a<a< a< r%c d|jz S)a Return the inversion of this interval within an octave. For instance, seconds become sevenths, octaves become unisons, and vice versa. All are undirected intervals. >>> interval.GenericInterval(4).mod7inversion 5 >>> interval.GenericInterval('Descending Octave').mod7inversion 1 >>> interval.GenericInterval(9).mod7inversion 7 rJ)rrSs r& mod7inversionzGenericInterval.mod7inversions 4,,,,r%cl|jtjk(r |jS|jS)a Return this interval as a number 1-7, that is, within an octave, but unlike simpleDirected or simpleUndirected, turn descending seconds into sevenths, etc. Used for calculating step names. For instance, going down a step from C, or GenericInterval(-2), would give a B, which is the same as GenericInterval(7) (not counting octaves), but going up a step from C, or GenericInterval(2) is D, which is the same as going up a 9th. >>> interval.GenericInterval(-2).mod7 7 >>> interval.GenericInterval(2).mod7 2 >>> interval.GenericInterval(9).mod7 2 >>> interval.GenericInterval('Unison').mod7 1 >>> interval.GenericInterval('Descending Octave').mod7 1 >>> interval.GenericInterval(15).mod7 1 See :meth:`music21.chord.Chord.semitonesFromChordStep` for a place this is used. )rrr!r3r rSs r&mod7zGenericInterval.mod7 s.8 >>Y11 1%% %&& &r%c,t|jS)a Returns a new GenericInterval object where 3rds are 6ths, etc. >>> third = interval.GenericInterval('Third') >>> third.complement() Note that currently direction is lost after a complement relationship: >>> fourth = interval.GenericInterval(-4) >>> fourthComp = fourth.complement() >>> fourthComp >>> fourthComp.directed 5 Called more than once, this may return the exact identical object: >>> fourthComp.complement() is fourthComp.complement() True )rr3rSs r& complementzGenericInterval.complement/s.t1122r%c|jdk(r tdSt|jd|jzzS)a> Returns a new GenericInterval object that is inverted. >>> aInterval = interval.GenericInterval('Third') >>> aInterval.reverse() >>> aInterval = interval.GenericInterval(-13) >>> aInterval.direction >>> aInterval.reverse() Unisons invert to unisons >>> aInterval = interval.GenericInterval(1) >>> aInterval.reverse() rr)rrrrSs r&rzGenericInterval.reverseHs8( ??a "1% %"4??b4>>6I#JK Kr%Frc|jd}nd}|j}|r|}ntj|}||jz|_|rd|_|s|Sy)a? transpose a pitch, retaining the accidental if any. >>> aPitch = pitch.Pitch('g4') >>> genericFifth = interval.GenericInterval(5) >>> bPitch = genericFifth.transposePitch(aPitch) >>> bPitch If inPlace is True then applied to the current pitch: >>> gPitch = pitch.Pitch('g4') >>> genericFifth = interval.GenericInterval(5) >>> genericFifth.transposePitch(gPitch, inPlace=True) >>> gPitch A generic interval transformation retains accidentals: >>> a2 = pitch.Pitch('B-') >>> cPitch = genericFifth.transposePitch(a2) >>> cPitch >>> a2.octave == cPitch.octave True Can be done inPlace as well, in which case, nothing is returned: >>> gSharp = pitch.Pitch('g#4') >>> genericFifth = interval.GenericInterval(5) >>> genericFifth.transposePitch(gSharp, inPlace=True) >>> gSharp NTF)rdiatonicNoteNumrrr1)rTpruseImplicitOctavepitchDNNrs r&rzGenericInterval.transposePitchasfF 88  $  % $$ H}}Q'H#+d.@.@#@ "HOOr%cddlm}||j||S|j|j}| |j nd}|j |j j nd}||z }|j||} |r|} |j| j} | | j nd} | |z} | dk7r|j| | _n| j d| _|s| Sy)a Transposes a pitch while remaining aware of its key context, for modal transposition: If k is None, works the same as `.transposePitch`: >>> aPitch = pitch.Pitch('g4') >>> genericFifth = interval.GenericInterval(5) >>> bPitch = genericFifth.transposePitchKeyAware(aPitch, None) >>> bPitch But if a key or keySignature (such as one from `.getContextByClass(key.KeySignature)`) is given, then the fun begins: >>> fis = pitch.Pitch('F#4') >>> e = pitch.Pitch('E') >>> gMaj = key.Key('G') >>> genericStep = interval.GenericInterval('second') >>> genericStep.transposePitchKeyAware(fis, gMaj) >>> genericStep.transposePitchKeyAware(e, gMaj) If a pitch already has an accidental that contradicts the current key, the difference between that pitch and the new key is applied to the new pitch: >>> fNat = pitch.Pitch('F4') >>> genericStep.transposePitchKeyAware(fNat, gMaj) inPlace should work: >>> genericStep.transposePitchKeyAware(fis, gMaj, inPlace=True) >>> fis This is used for Stream.transpose when a GenericInterval is given: >>> s = converter.parse('tinyNotation: 4/4 d4 e f f# g1 a-4 g b- a c1') >>> s.measure(1).insert(0, key.Key('G')) >>> s.measure(3).insert(0, key.Key('c')) >>> s2 = s.transpose(interval.GenericInterval(2)) >>> s2.show('text') {0.0} {0.0} {0.0} {0.0} {0.0} {1.0} {2.0} {3.0} {4.0} {0.0} {8.0} {0.0} {0.0} {1.0} {2.0} {3.0} {12.0} {0.0} {4.0} Does not take into account harmonic or melodic minor. rrNr)music21rraccidentalByStepstepalter accidental Accidental) rTr;krrr@ stepAlterpAlter offsetFromKeyrnewAccidentalByStep newStepAlter newPitchAlters r&transposePitchKeyAwarez&GenericInterval.transposePitchKeyAwaresT " 9&&q'&: :--aff5.>.J$**PQ '(||'?##Q* &&q'&: H00?4G4S*00YZ $}4 A "2%"2"2="AH   ,"&H Or%ct||S)aI Given a specifier, return a :class:`~music21.interval.DiatonicInterval` object. Specifier should be provided as an `interval.Specifier` enumeration or a string name, such as 'dd', 'M', or 'perfect'. >>> third = interval.GenericInterval('Third') >>> third.getDiatonic(interval.Specifier.MAJOR) >>> third.getDiatonic('minor') >>> third.getDiatonic('d') >>> third.getDiatonic(interval.Specifier.TRPAUG) Old in, specifier values are also allowed >>> third.getDiatonic(2) >>> fifth = interval.GenericInterval('fifth') >>> fifth.getDiatonic('perfect') >>> fifth.getDiatonic('major') Traceback (most recent call last): music21.interval.IntervalException: Cannot create a 'Major Fifth' )DiatonicInterval)rTrs r& getDiatoniczGenericInterval.getDiatonics< 400r%)Unison)rR int | strrqrQ)rrQrqrrqr)rqztuple[int, int])r)rQrqrOrprqrr;rrN)r;rrEzkey.KeySignature | Nonerr)rzSpecifier | strrqrN)(rrr rrrrrrr~rRsetterrrrr rrrrrrrrr r"r$r*r]r-r/r1r3r5rr7rrrLrO __classcell__rs@r&rrszxt#+++"> \\   __''* # #$$  # #$$   . .$$& . .%%&$$"((( 2 2P 22( 8 8 < <  *--"''B330L29>3p$(b  b b !b  bH1r%rceZdZUdZdddZded< d& d'fd Zd(dZd Zd Z e d(d Z e d(d Z e d(d Z e d(dZe d(dZe d(dZe d(dZe d)dZe d(dZe d(dZe d(dZe d(dZe d(dZe d(dZe d*dZe d*dZe d*dZe d*dZe d(dZe d(dZd+dZd,d Z d!d"d-d#Z!e d(d$Z"e d.d%Z#xZ$S)/rNa A class representing a diatonic interval. Two required arguments are a string `specifier` (such as perfect, major, or minor) and `generic`, either an int of an interval size (such as 2, 2nd, or second) or a :class:`~music21.interval.GenericInterval` object. Two DiatonicIntervals are the same if their GenericIntervals are the same and their specifiers are the same and they should be if their directions are the same, but this is not checked yet. The `specifier` is an enumeration/Specifier object. The `generic` is an integer or GenericInterval instance. >>> unison = interval.DiatonicInterval(interval.Specifier.PERFECT, 1) >>> unison >>> unison.simpleName 'P1' >>> unison.specifier >>> unison.generic >>> unison.direction The first value can be a string: >>> major3a = interval.DiatonicInterval('major', 3) >>> major3a.simpleName 'M3' >>> major3a.niceName 'Major Third' >>> major3a.semiSimpleName 'M3' >>> major3a.directedSimpleName 'M3' >>> major3a.mod7inversion 'm6' Or the first attribute can be a string abbreviation (not case sensitive, except Major vs. minor): >>> major3b = interval.DiatonicInterval('M', 3) >>> major3b.niceName 'Major Third' A string can be given for the second argument (generic interval): >>> major3c = interval.DiatonicInterval('major', 'third') >>> major3c.niceName 'Major Third' >>> p8 = interval.DiatonicInterval('perfect', 'octave') >>> p8.niceName 'Perfect Octave' >>> genericTenth = interval.GenericInterval(10) >>> minor10 = interval.DiatonicInterval('m', genericTenth) >>> minor10.mod7 'm3' >>> minor10.isDiatonicStep False >>> minor10.isStep False >>> aInterval = interval.DiatonicInterval('major', 2) >>> aInterval.isDiatonicStep True >>> aInterval.isStep True >>> augAscending = interval.DiatonicInterval('augmented', 1) >>> augAscending >>> augAscending.isDiatonicStep False >>> augAscending.isStep # TODO: should this be True??? False >>> augAscending.directedNiceName 'Ascending Augmented Unison' For Augmented Unisons, the diatonic interval is ascending while the `.generic` is oblique: >>> augAscending.direction >>> augAscending.generic.direction >>> dimDescending = augAscending.reverse() >>> dimDescending >>> dimDescending.directedNiceName 'Descending Diminished Unison' >>> dimDescending.direction This raises an error: >>> interval.DiatonicInterval('Perfect', -1) Traceback (most recent call last): music21.interval.IntervalException: There is no such thing as a descending Perfect Unison zUA :class:`~music21.interval.Specifier` enum representing the Quality of the interval.zTA :class:`~music21.interval.GenericInterval` enum representing the general interval.)rrzdict[str, str] _DOC_ATTRc t|di|||t|tr||_nDt j |st|trt||_ntd|t||_ |jtjtjfvr|jjs3|jtjk(rP|jjs:td|jj d|jj d|jtjk(r%|jj"dk(r tdyy)Nzincorrect generic argument: zCannot create a ' 'rz5There is no such thing as a descending Perfect Unisonr$)rrrrrrisIntrOrhrrrBrtrur$rsr]rR)rTrrrrs r&rzDiatonicInterval.__init__s# $8$  g /"DL \\' "j#&>*73DL$&B7+$NO O( 2 ^^ A AdllF^F^NNi&7&77 @X@X##DNN$;$;#S>S=TTUV  >>Y.. .4<<3E3E3K#$[\ \4L .r%c|jSrNrXrSs r&rzDiatonicInterval._reprInternals yyr%ct|dsyt|dsy|j|jk(r3|j|jk(r|j|jk(ryy)a. True if generic, specifier, and direction are the same. >>> a = interval.DiatonicInterval('major', 3) >>> b = interval.DiatonicInterval('minor', 3) >>> c = interval.DiatonicInterval('major', 3) >>> d = interval.DiatonicInterval('diminished', 4) >>> a == b False >>> a == c True >>> a == d False >>> e = interval.DiatonicInterval('d', 4) >>> d == e True Intervals do not compare to strings: >>> e == 'd4' False rFrT)r;rrrrs r&rzDiatonicInterval.__eq__sV.ui( , LLEMM )%//1NNeoo5r%ct|dz SrrrSs r&rzDiatonicInterval.__hash__rr%clt|jt|jjzS)z The name of the interval in abbreviated form without direction. >>> interval.DiatonicInterval('Perfect', 'Fourth').name 'P4' >>> interval.DiatonicInterval(interval.Specifier.MAJOR, -6).name 'M6' )rOrrrrSs r&rYzDiatonicInterval.names'4>>"S)@)@%AAAr%cb|jjdz|jjzS)z Return the full form of the name of a Diatonic interval >>> interval.DiatonicInterval('P', 4).niceName 'Perfect Fourth' r])rr]rrSs r&r]zDiatonicInterval.niceNames(~~&&,t||/D/DDDr%c.|jjS)z Same as `.specifier.niceName` -- the nice name of the specifier alone >>> p12 = interval.DiatonicInterval('P', -12) >>> p12.specificName 'Perfect' )rr]rSs r& specificNamezDiatonicInterval.specificNames~~&&&r%clt|jt|jjzS)z Return the name of a Diatonic interval removing octaves >>> interval.DiatonicInterval('Augmented', 'Twelfth').simpleName 'A5' )rOrrrrSs r& simpleNamezDiatonicInterval.simpleNames'4>>"S)F)F%GGGr%cb|jjdz|jjzS)z Return the full name of a Diatonic interval, simplifying octaves >>> interval.DiatonicInterval('d', 14).simpleNiceName 'Diminished Seventh' r])rr]rr-rSs r&r-zDiatonicInterval.simpleNiceNames(~~&&,t||/J/JJJr%clt|jt|jjzS)aX Return the name of a Diatonic interval removing octaves except that octaves (and double octaves) themselves are 8 instead of 1 >>> interval.DiatonicInterval('Augmented', 'Twelfth').semiSimpleName 'A5' >>> interval.DiatonicInterval('Diminished', 'Descending Octave').semiSimpleName 'd8' )rOrrrrSs r&semiSimpleNamezDiatonicInterval.semiSimpleName s'4>>"S)J)J%KKKr%cb|jjdz|jjzS)a Return the full name of a Diatonic interval removing octaves except that octaves (and double octaves) themselves are 8 instead of 1 >>> interval.DiatonicInterval('Augmented', 'Twelfth').semiSimpleNiceName 'Augmented Fifth' >>> interval.DiatonicInterval('Diminished', 'Descending Octave').semiSimpleNiceName 'Diminished Octave' r])rr]rr/rSs r&r/z#DiatonicInterval.semiSimpleNiceNames(~~&&,t||/N/NNNr%c|jjdk7r|jjS|jtj k(r|jjSt j|jt jtjkrtjStjS)a The direction of the DiatonicInterval: >>> interval.DiatonicInterval('Augmented', 'Twelfth').direction >>> interval.DiatonicInterval('M', -2).direction >>> interval.DiatonicInterval('P', 1).direction In the absence of other evidence, assumes that augmented unisons are ascending and diminished unisons are descending: >>> interval.DiatonicInterval('d', 1).direction >>> interval.DiatonicInterval('A', 1).direction Note that in the case of non-perfect unisons/primes, the `.generic.direction` will be `OBLIQUE` while the diatonic direction may be ASCENDING, DESCENDING, or OBLIQUE. >>> interval.DiatonicInterval('A', 1).generic.direction r) rrrrrBrsperfSpecifiersrrwrr!r#rSs r&rzDiatonicInterval.direction#s> << " "a '<<)) ) >>Y.. .<<)) )    />3G3G H\H\3] ]'' '&& &r%clt|jt|jjzS)z The name of the interval in abbreviated form with direction. >>> interval.DiatonicInterval('Minor', -6).directedName 'm-6' )rOrrrrSs r& directedNamezDiatonicInterval.directedNamePs'4>>"S)>)>%???r%cHt|jdz|jzS)a. The name of the interval in full form with direction. >>> interval.DiatonicInterval('P', 11).directedNiceName 'Ascending Perfect Eleventh' >>> interval.DiatonicInterval('Diminished', 'Descending Octave').directedNiceName 'Descending Diminished Octave' r])rrr]rSs r&directedNiceNamez!DiatonicInterval.directedNiceNameZs!dnn-3dmmCCr%clt|jt|jjzS)z The name of the interval in abbreviated form with direction, reduced to one octave >>> interval.DiatonicInterval('Minor', -14).directedSimpleName 'm-7' )rOrrr rSs r&directedSimpleNamez#DiatonicInterval.directedSimpleNamefs'4>>"S)D)D%EEEr%cHt|jdz|jzS)aL The name of the interval, reduced to within an octave, in full form with direction. >>> interval.DiatonicInterval('P', 11).directedNiceName 'Ascending Perfect Eleventh' >>> interval.DiatonicInterval('Diminished', 'Descending Octave').directedNiceName 'Descending Diminished Octave' r])rrr-rSs r&directedSimpleNiceNamez'DiatonicInterval.directedSimpleNiceNameps#dnn-3d6I6IIIr%clt|jt|jjzS)a> The name of the interval in abbreviated form with direction, reduced to one octave, except for octaves themselves >>> interval.DiatonicInterval('Minor', -14).directedSemiSimpleName 'm-7' >>> interval.DiatonicInterval('P', 'Octave').directedSemiSimpleName 'P8' )rOrrr"rSs r&directedSemiSimpleNamez'DiatonicInterval.directedSemiSimpleName|s'4>>"S)H)H%IIIr%cHt|jdz|jzS)a@ The name of the interval in full form with direction. >>> interval.DiatonicInterval('P', 11).directedSemiSimpleNiceName 'Ascending Perfect Fourth' >>> interval.DiatonicInterval('Diminished', 'Descending Octave').directedSemiSimpleNiceName 'Descending Diminished Octave' r])rrr/rSs r&directedSemiSimpleNiceNamez+DiatonicInterval.directedSemiSimpleNiceNames#dnn-3d6M6MMMr%c.|jjS)z Same as GenericInterval.isStep and .isDiatonicStep >>> interval.DiatonicInterval('M', 2).isStep True >>> interval.DiatonicInterval('P', 5).isStep False )rrrSs r&rzDiatonicInterval.isStep||"""r%c.|jjS)z Same as GenericInterval.isDiatonicStep and .isStep >>> interval.DiatonicInterval('M', 2).isDiatonicStep True >>> interval.DiatonicInterval('P', 5).isDiatonicStep False )rrrSs r&rzDiatonicInterval.isDiatonicSteps||***r%c.|jjS)z Same as GenericInterval.isSkip >>> interval.DiatonicInterval('M', 2).isSkip False >>> interval.DiatonicInterval('P', 5).isSkip True )rr rSs r&r zDiatonicInterval.isSkipr|r%c.|jjS)a Is the generic component of this interval able to be made perfect? That is, is this a type of unison, fourth, fifth, or octave (or larger component). Note that this does not ask if THIS interval is perfect. A diminished fifth is not perfect, but as a fifth it is perfectable. An augmented seventh sounds like a perfect octave but no seventh can ever be perfect. >>> interval.DiatonicInterval('M', 2).perfectable False >>> interval.DiatonicInterval('P', 12).perfectable True >>> interval.DiatonicInterval('A', 12).perfectable True )rr$rSs r&r$zDiatonicInterval.perfectables(||'''r%ct|jjt|jjzS)a- Return an inversion of the interval within an octave, losing direction. Returns as a string. >>> interval.DiatonicInterval('M', 2).mod7inversion 'm7' >>> interval.DiatonicInterval('A', 4).mod7inversion 'd5' >>> interval.DiatonicInterval('P', 1).mod7inversion 'P8' Everything is within an octave: >>> interval.DiatonicInterval('M', 9).mod7inversion 'm7' Direction is lost: >>> interval.DiatonicInterval('d', -3).mod7inversion 'A6' )rOrrarr3rSs r&r3zDiatonicInterval.mod7inversions0.4>>++-.T\\5O5O1PPPr%cl|jtjk(r |jS|jS)a` Return this interval as string of a specifier followed by a number 1-7, representing a diatonic interval within an octave, but unlike simpleDirected or simpleUndirected, turns descending seconds into sevenths, etc. For instance, going down a minor second from C would give a B, which is the same as going up a major seventh to B. This method gives a string representing a diatonic interval that will reach the same note as this DiatonicInterval but within an octave up from the basic note. >>> interval.DiatonicInterval('m', -2).mod7 'M7' >>> interval.DiatonicInterval('m', 2).mod7 'm2' >>> interval.DiatonicInterval('M', 9).mod7 'M2' >>> interval.DiatonicInterval('Perfect', 'Unison').mod7 'P1' >>> interval.DiatonicInterval('Perfect', 'Descending Octave').mod7 'P1' >>> interval.DiatonicInterval(interval.Specifier.AUGMENTED, -4).mod7 'd5' See :meth:`music21.chord.Chord.semitonesFromChordStep` for a place this is used. )rrr!r3rhrSs r&r5zDiatonicInterval.mod7s,> >>Y11 1%% %?? "r%c|jjdk(r$t|jj dSt|j|jj S)a  Return a :class:`~music21.interval.DiatonicInterval` that is an inversion of this Interval. >>> aInterval = interval.DiatonicInterval('major', 3) >>> aInterval.reverse().directedName 'M-3' >>> aInterval = interval.DiatonicInterval('augmented', 5) >>> aInterval.reverse().directedName 'A-5' (Ascending) Augmented Unisons reverse to (Descending) Diminished Unisons and vice versa >>> aug1 = interval.DiatonicInterval('augmented', 1) >>> aug1.direction >>> aug1.directedName 'A1' >>> dimUnison = aug1.reverse() >>> dimUnison.directedName 'd1' >>> dimUnison.directedNiceName 'Descending Diminished Unison' r)rrrNrrarrSs r&rzDiatonicInterval.reversesS6 << A %#DNN$<$<$>B B#DNN$(LL$8$8$:< >> aInterval = interval.DiatonicInterval('major', 'third') >>> aInterval.niceName 'Major Third' >>> aInterval.getChromatic() >>> aInterval = interval.DiatonicInterval('augmented', -5) >>> aInterval.niceName 'Augmented Fifth' >>> aInterval.getChromatic() >>> aInterval = interval.DiatonicInterval('minor', 'second') >>> aInterval.niceName 'Minor Second' >>> aInterval.getChromatic() rHrr)rQrrr1semitonesGenericrr$rrkrorrr!ChromaticInterval)rT octaveOffsetsemitonesStartsemitonesAdjustrs r& getChromaticzDiatonicInterval.getChromatic4s43t||99:Q>? )$,,*G*GH << # #"nnBBDO#nn@@BO!B&.8?J << ! !Y%9%9 9 OI ++r%Frc^t||j}|j||S)a Calls transposePitch from a full interval object. This is not particularly optimized since it requires creating both a ChromaticInterval object and a full Interval object. But it's here for completeness. >>> di = interval.DiatonicInterval('P', 11) >>> p = pitch.Pitch('C#4') >>> di.transposePitch(p) Previous pitch was unchanged. inPlace=True changes that. >>> p >>> di.transposePitch(p, inPlace=True) >>> p * Changed in v6: added inPlace. diatonic chromaticr)rrr)rTr;rfullIntervalObjects r&rzDiatonicInterval.transposePitch_s00&tt?P?P?RS!00G0DDr%c(t|jS)z Returns the abbreviation for the specifier. >>> i = interval.Interval('M-10') >>> d = i.diatonic >>> d.specifierAbbreviation 'M' )rPrrSs r&specifierAbbreviationz&DiatonicInterval.specifierAbbreviationzs4>>**r%c@|j}|r |jSy)a Return the number of cents in this interval. Returns a float, always assuming an equal-tempered presentation. >>> i = interval.DiatonicInterval('minor', 'second') >>> i.niceName 'Minor Second' >>> i.cents 100.0 g)rr)rTcs r&rzDiatonicInterval.centss!     77Nr%)r0r)rz str | intrzint | GenericInterval | strrprSrTrqrNrqrrVrqfloat)%rrr rrr[__annotations__rrrrr~rYr]rfrhr-rkr/rrprrrtrvrxrzrrr r$r3r5rrrrrrXrYs@r&rNrNs=fP6-!I~'*45]#]1]<$L B BEE''HHKK L L O O*'*'X@@ D DFF J J J J N N # # + + # #((*QQ2!#!#PE6 + +r%rNc eZdZdZddfd ZddZdZdZeddZ eddZ eddZ edd Z edd Z edd Zedd Zedd ZeddZeddZddZddZddddZxZS) ra Chromatic interval class. Unlike a :class:`~music21.interval.DiatonicInterval`, this IntervalBase subclass treats interval spaces in half-steps. So Major 3rd and Diminished 4th are the same. Two ChromaticIntervals are equal if their size and direction are equal. >>> aInterval = interval.ChromaticInterval(-14) >>> aInterval.semitones -14 >>> aInterval.undirected 14 >>> aInterval.mod12 10 >>> aInterval.intervalClass 2 >>> aInterval.isChromaticStep False >>> aInterval.isStep False >>> aInterval = interval.ChromaticInterval(1) >>> aInterval.isChromaticStep True >>> aInterval.isStep True c dt|di||t|k(r t|}||_y)Nr$)rrrQr)rTrrrs r&rzChromaticInterval.__init__s/ $8$ I &II$-r%c,t|jSrNrrSs r&rzChromaticInterval._reprInternalrr%cRt|dsy|j|jk(ryy)a True if number of semitones is the same. >>> a = interval.ChromaticInterval(-14) >>> b = interval.ChromaticInterval(14) >>> c = interval.ChromaticInterval(-14) >>> d = interval.ChromaticInterval(7) >>> e = interval.ChromaticInterval(2) >>> a == b False >>> a == c True >>> a == d False >>> b == e False Intervals do not equal numbers: >>> interval.ChromaticInterval(7) == 7 False rFT)r;rrs r&rzChromaticInterval.__eq__s'0uk* >>U__ ,r%ct|dz SrrrSs r&rzChromaticInterval.__hash__rr%c4t|jdzdS)z Return the number of cents in a ChromaticInterval: >>> dime = interval.ChromaticInterval(0.1) >>> dime.cents 10.0 rrF)roundrrSs r&rzChromaticInterval.centssT^^e+Q//r%c|jS)z A synonym for `.semitones` >>> tritoneDown = interval.ChromaticInterval(-6) >>> tritoneDown.directed -6 rrSs r&rzChromaticInterval.directeds~~r%c,t|jS)z The absolute value of the number of semitones: >>> tritoneDown = interval.ChromaticInterval(-6) >>> tritoneDown.undirected 6 )rrrSs r&rzChromaticInterval.undirecteds4>>""r%c|jdkDrtjS|jdkrtjStjS)a Returns an enum of the direction: >>> interval.ChromaticInterval(-3).direction note that the number can be helpful for multiplication: >>> interval.ChromaticInterval(-3).direction * 9 -9 r)rrr#r!r"rSs r&rzChromaticInterval.direction s@ ==1 && & ==1 '' '   r%c |jdzS)a The number of semitones within an octave using modulo arithmatic. (see :meth:`~music21.interval.ChromaticInterval.simpleUndirected` for a similar method that puts musical intuition above mathematical intuition) >>> interval.ChromaticInterval(15).mod12 3 >>> interval.ChromaticInterval(-4).mod12 8 >>> interval.ChromaticInterval(-16).mod12 8 rrrSs r&mod12zChromaticInterval.mod12 s ~~""r%c |jdzS)a The number of semitones within an octave while ignoring direction. (see :meth:`~music21.interval.ChromaticInterval.mod12` for a similar method that puts mathematical intuition above musical intuition) >>> interval.ChromaticInterval(15).simpleUndirected 3 >>> interval.ChromaticInterval(-4).simpleUndirected 4 >>> interval.ChromaticInterval(-16).simpleUndirected 4 rr rSs r&rz"ChromaticInterval.simpleUndirected- s ##r%cr|jtjk(rd|jzS|jS)a& The number of semitones within an octave while preserving direction. >>> interval.ChromaticInterval(15).simpleDirected 3 >>> interval.ChromaticInterval(-4).simpleDirected -4 >>> interval.ChromaticInterval(-16).simpleDirected -4 r)rrr!rrSs r&r z ChromaticInterval.simpleDirected? s3 >>Y11 1--- -(( (r%cDt|j}|dkDrd|z S|S)NrGr)rQr)rTrs r& intervalClasszChromaticInterval.intervalClassP s%DJJ 19: Lr%c |jdk(S)Nrr rSs r&isChromaticStepz!ChromaticInterval.isChromaticStepX s!##r%c|jSrN)rrSs r&rzChromaticInterval.isStep\ s###r%cLt|jd|jzzS)a Return an inverted :class:`~music21.interval.ChromaticInterval`, that is, reversing the direction. >>> aInterval = interval.ChromaticInterval(-14) >>> aInterval.reverse() >>> aInterval = interval.ChromaticInterval(3) >>> aInterval.reverse() r)rrrrSs r&rzChromaticInterval.reversed s!!B4G!HIIr%cJt|j\}}t||S)a Given a ChromaticInterval, return a :class:`~music21.interval.DiatonicInterval` object of the same size. While there is more than one Generic Interval for any given chromatic interval, this is needed to permit easy chromatic specification of Interval objects. Augmented or diminished intervals are never returned except for the interval of 6 which returns a diminished fifth, not augmented fourth. >>> aInterval = interval.ChromaticInterval(5) >>> aInterval.getDiatonic() >>> aInterval = interval.ChromaticInterval(6) >>> aInterval.getDiatonic() >>> aInterval = interval.ChromaticInterval(7) >>> aInterval.getDiatonic() >>> aInterval = interval.ChromaticInterval(11) >>> aInterval.getDiatonic() )rrrN)rTrrs r&rOzChromaticInterval.getDiatonics s$8?t~~N 7 733r%Frc|jd}nd}|j}|stj|}n|}||jz|_|durd|_|s|Sy)a/ Given a :class:`~music21.pitch.Pitch` object, return a new, transposed Pitch, that is transformed according to this ChromaticInterval. Because :class:`~music21.interval.ChromaticInterval` object do not take into account diatonic spelling, the new Pitch is simplified to the most common intervals. See :meth:`~music21.pitch.Pitch.simplifyEnharmonic` with ``mostCommon = True`` to see the results. >>> tritone = interval.ChromaticInterval(6) >>> p = pitch.Pitch('E#4') >>> p2 = tritone.transposePitch(p) >>> p2 >>> p3 = tritone.transposePitch(p2) >>> p3 If no octave number is given then octaves "wrap around" and thus even after transposing upward, you could end up with a pitch that is displayed as lower than the original: >>> p4 = pitch.Pitch('B') >>> p4.ps 71.0 >>> p5 = tritone.transposePitch(p4) Since the octave on p4 was implicit, the ps here wraps around >>> p5.ps 65.0 Afterward, the spelling of the new pitch will always be inferred. >>> p4.spellingIsInferred False >>> p5.spellingIsInferred True Can be done inPlace as well: >>> p = pitch.Pitch('E#4') >>> tritone.transposePitch(p, inPlace=True) >>> p >>> p.spellingIsInferred True * Changed in v6: added inPlace. NTF)rrrrr)rTr;rr<ppsrs r&rz ChromaticInterval.transposePitch sfl 88  $  % dd}}Q'HHDNN*  $"HOOr%)r)r int | floatrprrqrrSrRrTrrrV)rrr rrrrrrr~rrrrrrr rrrrrOrrXrYs@r&rrs8."@ 00##!!&##"$$")) $$$$ J4>9>FFr%rc4d}d|vr|jdd}d}nd}|j}d|vr4tjdd|tjj }d}n5d |vr1tjd d|tjj }|d vrd }d }n|dvrd}d }t tjD]V\}}|j|vstjd|dt||tjj }Xtj|\}} t||z}|} t|} | j| } | | j!|fS#t$r} td|d|d| d} ~ wwxYw)a= A function for processing interval strings and returning diatonic and chromatic interval objects. Used by the Interval class, below. The last entry is a boolean indicating whether the diatonic interval is inferred (see 'half' and 'whole') >>> interval._stringToDiatonicChromatic('P5') (, , False) >>> interval._stringToDiatonicChromatic('p5') (, , False) >>> interval._stringToDiatonicChromatic('perfect5') (, , False) >>> interval._stringToDiatonicChromatic('perfect fifth') (, , False) >>> interval._stringToDiatonicChromatic('P-5') (, , False) >>> interval._stringToDiatonicChromatic('M3') (, , False) >>> interval._stringToDiatonicChromatic('m3') (, , False) >>> interval._stringToDiatonicChromatic('whole') (, , True) >>> interval._stringToDiatonicChromatic('half') (, , True) >>> interval._stringToDiatonicChromatic('-h') (, , True) >>> interval._stringToDiatonicChromatic('semitone') (, , True) F-rrr descendingz descending\s*)flags ascendingz ascending\\s*)wwholetoneM2T)hhalfsemitonem2z\s*zCould not find an int in z, from rN)rrresub RegexFlag IGNORECASErrr&rO getNumFromStrrQr<rhrrOr) rRinferredr value_lowerrordinalfoundremain genericNumbervespecName gInterval dIntervals r&_stringToDiatonicChromaticr sHH e| c2&++-K{"'U",,:Q:QR  #'U",,:Q:QR,, 1 1 4 45 7 ==?k )FFc'#.q6 !#!8!8E6((/ME6E X- H .I%%h/I i,,. 88 'yy B  s7E66 F?FFct|t|}}|j|jz }t|}t|S)a4 Given two :class:`~music21.note.Note` objects, returns a :class:`~music21.interval.GenericInterval` object. Works equally well with :class:`~music21.pitch.Pitch` objects >>> aNote = note.Note('c4') >>> bNote = note.Note('g5') >>> aInterval = interval.notesToGeneric(aNote, bNote) >>> aInterval >>> aPitch = pitch.Pitch('c#4') >>> bPitch = pitch.Pitch('f-5') >>> bInterval = interval.notesToGeneric(aPitch, bPitch) >>> bInterval )rr:rr)n1n2p1p2rgenDists r&notesToGenericr. sB,b!=#4R""R%7%77I,Y7G 7 ##r%crt|t|}}t|j|jz S)a" Given two :class:`~music21.note.Note` objects, returns a :class:`~music21.interval.ChromaticInterval` object. Works equally well with :class:`~music21.pitch.Pitch` objects. >>> aNote = note.Note('c4') >>> bNote = note.Note('g#5') >>> interval.notesToChromatic(aNote, bNote) >>> aPitch = pitch.Pitch('c#4') >>> bPitch = pitch.Pitch('f-5') >>> bInterval = interval.notesToChromatic(aPitch, bPitch) >>> bInterval )rrr)rrrrs r&notesToChromaticrJ s.*b!=#4R RUURUU] ++r%cd}||jdz d|jzz}|j|jk7rJ|jtjk7r-|jtjk7rd|j z}n(|j dk(r |j }n |j }|j dkDrd}nd}tt||z}|jr tt|z|z }|S tt |z|z }|S#t$r }tdt||z z|d }~wwxYw#t$r }td t||z z|d }~wwxYw) aX Given a :class:`~music21.interval.GenericInterval` and a :class:`~music21.interval.ChromaticInterval` object, return a specifier (i.e. Specifier.MAJOR, Specifier.MINOR, etc.). >>> aInterval = interval.GenericInterval('seventh') >>> bInterval = interval.ChromaticInterval(11) >>> interval._getSpecifierFromGenericChromatic(aInterval, bInterval) >>> interval.parseSpecifier('major') Absurdly altered interval: >>> cInterval = interval.GenericInterval('second') >>> dInterval = interval.ChromaticInterval(10) # 8x augmented second >>> interval._getSpecifierFromGenericChromatic(cInterval, dInterval) Traceback (most recent call last): music21.interval.IntervalException: cannot get a specifier for a note with this many semitones off of Major: 8 )rrCrErFrHrJrLrrrrg-C6?g-C6zKcannot get a specifier for a note with this many semitones off of Perfect: NzIcannot get a specifier for a note with this many semitones off of Major: )rrrrr"rrrQrr$rn perfOffsetr'rhrO specifiers majOffset) gIntcIntnoteVals normalSemis theseSemis roundingError semisRoundedries r&!_getSpecifierFromGenericChromaticrc s2&H400145T=S=S8SSK $..()"3"33)J[J[8[$//) A ]] __    uZ-789L  &zL'@;'NOI  "9|#;k#IJI  #%'*: +C'DE   ##%(k)A%BC  s0(D>D? D<D77D<? E(E##E(c2t||}t||S)a Given a :class:`~music21.interval.GenericInterval` and a :class:`~music21.interval.ChromaticInterval` object, return a :class:`~music21.interval.DiatonicInterval`. >>> aInterval = interval.GenericInterval('descending fifth') >>> bInterval = interval.ChromaticInterval(-7) >>> cInterval = interval.intervalsToDiatonic(aInterval, bInterval) >>> cInterval )rrN)rrrs r&intervalsToDiatonicr s2$=I It ,,r%ct|ts t|}n|}t|ts t|}n|}t||}t ||}t ||S)ak Given a :class:`~music21.interval.GenericInterval` and a :class:`~music21.interval.ChromaticInterval` object, return a full :class:`~music21.interval.Interval`. >>> aInterval = interval.GenericInterval('descending fifth') >>> bInterval = interval.ChromaticInterval(-8) >>> cInterval = interval.intervalFromGenericAndChromatic(aInterval, bInterval) >>> cInterval >>> cInterval.name 'A5' >>> cInterval.directedName 'A-5' >>> cInterval.directedNiceName 'Descending Augmented Fifth' >>> interval.intervalFromGenericAndChromatic(3, 4) >>> interval.intervalFromGenericAndChromatic(3, 3) >>> interval.intervalFromGenericAndChromatic(5, 6) >>> interval.intervalFromGenericAndChromatic(5, 5) >>> interval.intervalFromGenericAndChromatic(-2, -2) >>> interval.intervalFromGenericAndChromatic(1, 0.5) r)rrrrrNr)rrgIntVcIntVrdInts r&intervalFromGenericAndChromaticr s]N dO ,% d- .!$'1%?I Iu -D TU 33r%c &eZdZdZ d/dddddddd d0fdZdZfdZdZed1dZ ed2d Z ed2d Z ed2d Z ed2d Z ed2d Zed2dZed2dZed2dZed2dZed2dZed3dZed4dZed5dZed2dZed6dZed6dZed6dZed6dZd6dZed7dZed8dZed9dZd9dZ d d!d d" d:d#Z!d d$ d;d%Z"d&Z#edd*Z&ed?d+Z'e'jJd@d,Z'ed?d-Z(e(jJd@d.Z(xZ)S)Ara9 An Interval class that encapsulates both :class:`~music21.interval.ChromaticInterval` and :class:`~music21.interval.DiatonicInterval` objects all in one model. The interval is specified either as named arguments, a :class:`~music21.interval.DiatonicInterval` and a :class:`~music21.interval.ChromaticInterval`, or two :class:`~music21.note.Note` objects (or :class:`~music21.interval.Pitch` objects), from which both a ChromaticInterval and DiatonicInterval are derived. >>> p1 = pitch.Pitch('c3') >>> p2 = pitch.Pitch('c5') >>> aInterval = interval.Interval(pitchStart=p1, pitchEnd=p2) >>> aInterval >>> aInterval.name 'P15' >>> aInterval.pitchStart is p1 True >>> aInterval.pitchEnd is p2 True Reduce to less than an octave: >>> aInterval.simpleName 'P1' Reduce to no more than an octave: >>> aInterval.semiSimpleName 'P8' An interval can also be specified directly: >>> aInterval = interval.Interval('m3') >>> aInterval >>> aInterval = interval.Interval('M3') >>> aInterval >>> aInterval = interval.Interval('p5') >>> aInterval >>> aInterval.isChromaticStep False >>> aInterval.isDiatonicStep False >>> aInterval.isStep False Some ways of creating half-steps. >>> aInterval = interval.Interval('half') >>> aInterval >>> aInterval.isChromaticStep True >>> aInterval.isDiatonicStep True >>> aInterval.isStep True >>> aInterval = interval.Interval('-h') >>> aInterval >>> aInterval.directedName 'm-2' >>> aInterval.name 'm2' A single int is treated as a number of half-steps: >>> aInterval = interval.Interval(4) >>> aInterval >>> aInterval = interval.Interval(7) >>> aInterval If giving a starting pitch, an ending pitch has to be specified. >>> aInterval = interval.Interval(pitchStart=p1) Traceback (most recent call last): ValueError: either both the starting and the ending pitch (or note) must be given or neither can be given. You cannot have one without the other. An Interval can be constructed from a DiatonicInterval and ChromaticInterval object (or just one): >>> diaInterval = interval.DiatonicInterval('major', 'third') >>> chrInterval = interval.ChromaticInterval(4) >>> fullInterval = interval.Interval(diatonic=diaInterval, chromatic=chrInterval) >>> fullInterval >>> fullInterval = interval.Interval(diatonic=diaInterval) >>> fullInterval.semitones 4 >>> fullInterval = interval.Interval(chromatic=chrInterval) >>> fullInterval.diatonic.name 'M3' >>> fullInterval.implicitDiatonic True Two Intervals are the same if their Chromatic and Diatonic intervals are the same. >>> aInt = interval.Interval('P4') >>> bInt = interval.Interval( ... diatonic=interval.DiatonicInterval('P', 4), ... chromatic=interval.ChromaticInterval(5), ... ) >>> aInt == bInt True N.B. that interval.Interval('A4') != 'A4' >>> interval.Interval('A4') == 'A4' False More demonstrations using pitches: >>> aPitch = pitch.Pitch('c4') >>> bPitch = pitch.Pitch('g5') >>> aInterval = interval.Interval(aPitch, bPitch) >>> aInterval >>> bInterval = interval.Interval(pitchStart=aPitch, pitchEnd=bPitch) >>> aInterval.niceName == bInterval.niceName True >>> aPitch = pitch.Pitch('c#4') >>> bPitch = pitch.Pitch('f-5') >>> cInterval = interval.Interval(aPitch, bPitch) >>> cInterval >>> cPitch = pitch.Pitch('e#4') >>> dPitch = pitch.Pitch('f-4') >>> dInterval = interval.Interval(cPitch, dPitch) >>> dInterval >>> ePitch = pitch.Pitch('e##4') >>> fPitch = pitch.Pitch('f--4') >>> dInterval = interval.Interval(ePitch, fPitch) >>> dInterval >>> gPitch = pitch.Pitch('c--4') >>> hPitch = pitch.Pitch('c##4') >>> iInterval = interval.Interval(gPitch, hPitch) >>> iInterval >>> interval.Interval(pitch.Pitch('e##4'), pitch.Pitch('f--5')) * Changed in v8: - Pitches are emphasized over notes. - It is not possible to create an interval with a name and a pitchStart/noteStart and automatically get a pitchEnd/noteEnd in the process. Set them later. - Incompatible keywords raise ValueError not IntervalException. - An empty instantiation gives a P1 interval. OMIT_FROM_DOCS >>> aInterval = interval.Interval('M2') >>> aInterval.isChromaticStep False >>> aInterval.isDiatonicStep True >>> aInterval.isStep True >>> aInterval = interval.Interval('dd3') >>> aInterval.isChromaticStep True >>> aInterval.isDiatonicStep False >>> aInterval.isStep True This is in OMIT_FROM_etc. put changelog above. N)rr pitchStartpitchEnd noteStartnoteEndrYc dt|d i| d|_|| tdt |}|@t |t r|} n-t |ttfr t|}n t |}|r|s|r |r td|r t |}|r t |}|r|r|r |s td|r>|r>> a = interval.Interval('a4') >>> b = interval.Interval('d5') >>> c = interval.Interval('m3') >>> d = interval.Interval('d5') >>> a == b False >>> b == d True >>> a == c False >>> b in [a, c, d] True Now, of course, this makes sense: >>> a == 'hello' False But note well that this is also a False expression: >>> a == 'a4' False FT)rrrr)rTrrs r&rzInterval.__eq__" s:6w~e$ MMU^^ +NNeoo5r%ct|dz SrrrSs r&rzInterval.__hash__E rr%c.|jjS)z Returns the :class:`~music21.interval.GenericInterval` object associated with this Interval >>> interval.Interval('P5').generic )rrrSs r&rzInterval.genericJ s}}$$$r%c.|jjS)z Return the simple name of the interval, ignoring direction: >>> interval.Interval('Descending Perfect Fourth').name 'P4' )rrYrSs r&rYz Interval.nameU s}}!!!r%c.|jjS)zL >>> interval.Interval('m3').niceName 'Minor Third' )rr]rSs r&r]zInterval.niceName_ s }}%%%r%c.|jjSrN)rrhrSs r&rhzInterval.simpleNameg s}}'''r%c.|jjSrN)rr-rSs r&r-zInterval.simpleNiceNamek }}+++r%c.|jjSrN)rrkrSs r&rkzInterval.semiSimpleNameo rr%c.|jjSrN)rr/rSs r&r/zInterval.semiSimpleNiceNames }}///r%c.|jjSrN)rrprSs r&rpzInterval.directedNamew }})))r%c.|jjSrN)rrrrSs r&rrzInterval.directedNiceName{ s}}---r%c.|jjSrN)rrtrSs r&rtzInterval.directedSimpleName r r%c.|jjSrN)rrvrSs r&rvzInterval.directedSimpleNiceName s}}333r%c.|jjSrN)rrrSs r&rzInterval.semitones ~~'''r%c.|jjSrN)rrrSs r&rzInterval.direction rr%c.|jjSrN)rrrSs r&rzInterval.specifier s}}&&&r%c.|jjSrN)rrfrSs r&rfzInterval.specificName r r%c.|jjSrN)rrrSs r&rzInterval.isDiatonicStep rr%c.|jjSrN)rrrSs r&rzInterval.isChromaticStep s~~---r%c6|jxs |jSrN)rrrSs r&rzInterval.isStep s##:t':'::r%c.|jjSrN)rr rSs r&r zInterval.isSkip s}}###r%c"|jdvryy)a returns True if the pitches are a major or minor third or sixth or perfect fifth or unison. These rules define all common-practice consonances (and earlier back to about 1300 all imperfect consonances) >>> i1 = interval.Interval(note.Note('C'), note.Note('E')) >>> i1.isConsonant() True >>> i1 = interval.Interval(note.Note('B-'), note.Note('C')) >>> i1.isConsonant() False )rm3M3m6M6P1TF)rhrSs r& isConsonantzInterval.isConsonant s ??B Br%c@t|jjS)a Return a new :class:`~music21.interval.Interval` object that is the complement of this Interval. >>> aInterval = interval.Interval('M3') >>> bInterval = aInterval.complement >>> bInterval >>> cInterval = interval.Interval('A2') >>> dInterval = cInterval.complement >>> dInterval )rrr3rSs r&r7zInterval.complement s  3344r%c.|jjS)a Return the interval class from the chromatic interval, that is, the lesser of the number of half-steps in the simpleInterval or its complement. >>> aInterval = interval.Interval('M3') >>> aInterval.intervalClass 4 >>> bInterval = interval.Interval('m6') >>> bInterval.intervalClass 4 Empty intervals return 0: >>> interval.Interval().intervalClass 0 * Changed in v6.5: empty intervals return 0. )rrrSs r&rzInterval.intervalClass s,~~+++r%c.|jjS)a Return the cents from the chromatic interval, where 100 cents = a half-step >>> aInterval = interval.Interval('M3') >>> aInterval.cents 400.0 >>> p1 = pitch.Pitch('C4') >>> p2 = pitch.Pitch('D4') >>> p2.microtone = 30 >>> microtoneInterval = interval.Interval(pitchStart=p1, pitchEnd=p2) >>> microtoneInterval.cents 230.0 OMIT_FROM_DOCS >>> interval.Interval().cents 0.0 )rrrSs r&rzInterval.cents s*~~###r%cd|jj}|jj}||z S)z Return the number of cents the diatonic interval needs to be shifted to correspond to microtonal value specified in the chromatic interval. )rrr)rTdCentscCentss r&rz#Interval._diatonicIntervalCentShift s,$$%%r%FrE)r maxAccidentalrc|r"|jj|||S|d}|jr|jj||}n|j |||}|j I|j|j ||_|j j d|j _|s|Sy)a Given a :class:`~music21.pitch.Pitch` object, return a new, transposed Pitch, that is transformed according to this Interval. This is the main public interface to all transposition routines found on higher-level objects. The `maxAccidental` parameter sets an integer number of half step alterations that will be accepted in the transposed pitch before it is simplified. For example, a value of 2 will permit double sharps but not triple sharps. The maxAccidental default is 4, because music21 does not support quintuple sharps/flats. Set to None to try anyhow. >>> p1 = pitch.Pitch('A#4') >>> i = interval.Interval('m3') >>> p2 = i.transposePitch(p1) >>> p2 >>> p2 = i.transposePitch(p1, reverse=True) >>> p2 >>> i.transposePitch(p1, reverse=True, maxAccidental=1) `Pitch` objects without octaves are transposed also into objects without octaves. This might make them appear to be lower than the original even if transposed up: >>> anyA = pitch.Pitch('A') >>> anyC = i.transposePitch(anyA) >>> anyC >>> anyC.ps < anyA.ps # !! True If inPlace is True then function is done in place and no pitch is returned. >>> p1 = pitch.Pitch('A4') >>> i = interval.Interval('m3') >>> i.transposePitch(p1, inPlace=True) >>> p1 Note that reverse=True is only there for historical reasons; it is the same as `i.reverse().transposePitch(x)` and that format will be much faster when calling many times. * Changed in v6: inPlace parameter added. Reverse and maxAccidental changed to keyword only. OMIT_FROM_DOCS TODO: More tests here, esp. on fundamental. >>> p1 = pitch.Pitch('C4') >>> i = interval.Interval(1) # half-step, regardless of diatonic >>> p2 = i.transposePitch(p1) >>> p2 >>> p3 = i.transposePitch(p2) >>> p3 )r'rNir)r')rrrr_diatonicTransposePitch fundamentalr)rTr;rr'rpOuts r&rzInterval.transposePitch sH <<>00-Y`0a a  !M  >>001D //+0D == $#22 + 3 D  }}##+*.  'Kr%rcPd}|jdk(r6t|jtt|jk(rd}|jd}nd}|}t j |}|j}|jjj} || z} t| \} } | |_ | |_|j} d|_ d|_t||}|j j|j jz }|dk7rG|dk\r|dz }|jdz |_|dk\rt#||kDr|j$|z|_n||_ |sP|j|j|jj'|jd|j_n|jW|jd|_ t*j,r|jJ|jj'|jn^|j&|jj'|jn,d|j_n|r| | j.dk(r| |_ |rd|_|s|S|j.|_|j|_|S) z abstracts out the diatonic aspects of transposing, so that implicitDiatonic and regular diatonic can use some of the same code. PRIVATE METHOD: Return p even if inPlace is True FrTNrrrnatural)rhrrrQrrrr:rrr1rrArC microtonerrrrinheritDisplay displayStatusrrrY)rTr;r'rinheritAccidentalDisplayStatusr<rpitch2oldDiatonicNumdistanceToMovenewDiatonicNumbernewStep newOctaveoldPitch2Accidental interval2halfStepsToFixs r&r)z Interval._diatonicTransposePitchm sp05& ??d "uT^^'<c$..FY@Z'Z-1 * 88  $  % v&//..<<*^;89JK ! $// VV, 11I4G4G4Q4QQ Q  B&!/"!4 &  1 !B& >"]2#II6 $2!1$$0V5F5F5R%%44V5F5FG6:F%%3$$,((4,-)??#)#4#4#@@#@))889J9JK((4))889J9JK:?))7.(3/44 A(;F%  FMM ++FK"MMFMMr%c|j-|j!t|j|jSt|jj |j j S)a Return a reversed version of this interval. If :class:`~music21.pitch.Pitch` objects are stored as `pitchStart` and `pitchEnd`, these pitches are reversed. >>> p1 = pitch.Pitch('c3') >>> p2 = pitch.Pitch('g3') >>> intvP5 = interval.Interval(pitchStart=p1, pitchEnd=p2) >>> intvP5 >>> revInterval = intvP5.reverse() >>> revInterval >>> revInterval.pitchStart is intvP5.pitchEnd True >>> m3 = interval.Interval('m3') >>> m3.reverse() rrr)rrrrrrrSs r&rzInterval.reverse s^*    'DNN,Fdnnd>N>NO OT]]%:%:%<&*nn&<&<&>@ @r%c|jS)a Get the start pitch or set it a new value. Setting this will adjust the value of the end pitch (`pitchEnd`). >>> maj3 = interval.Interval('M3') >>> maj3.pitchStart = pitch.Pitch('c4') >>> maj3.pitchEnd.nameWithOctave 'E4' >>> p1 = pitch.Pitch('c3') >>> p2 = pitch.Pitch('g#3') >>> a5 = interval.Interval(p1, p2) >>> a5.name 'A5' >>> a5.pitchStart = pitch.Pitch('g4') >>> a5.pitchEnd.nameWithOctave 'D#5' >>> descM3 = interval.Interval('-M3') >>> descM3.pitchStart = pitch.Pitch('c4') >>> descM3.pitchEnd.nameWithOctave 'A-3' >>> descM2 = interval.Interval('M-2') >>> descM2.pitchStart = pitch.Pitch('A#3') >>> descM2.pitchEnd.nameWithOctave 'G#3' Implicit diatonic intervals do not need to follow the diatonic directed name: >>> halfStep = interval.Interval('h') >>> halfStep.directedName 'm2' >>> halfStep.implicitDiatonic True >>> halfStep.pitchStart = pitch.Pitch('F-3') >>> halfStep.pitchEnd.nameWithOctave 'F3' )rrSs r&rzInterval.pitchStart sVr%cd|d|_d|_y|j|}||_||_y)z Assuming that this interval is defined, we can set a new start Pitch (_pitchStart) and automatically set the end Pitch (_pitchEnd). Nrrr)rTr;r2s r&rzInterval.pitchStarts< 9#D !DN $$Q'r%c|jS)a Set the end pitch to a new value; this will adjust the value of the start pitch (`pitchStart`). >>> aInterval = interval.Interval('M3') >>> aInterval.pitchEnd = pitch.Pitch('E4') >>> aInterval.pitchStart.nameWithOctave 'C4' >>> aInterval = interval.Interval('m2') >>> aInterval.pitchEnd = pitch.Pitch('A#3') >>> aInterval.pitchStart.nameWithOctave 'G##3' >>> p1 = pitch.Pitch('G#3') >>> p2 = pitch.Pitch('C3') >>> aInterval = interval.Interval(p1, p2) >>> aInterval.directedName # downward augmented fifth 'A-5' >>> aInterval.pitchEnd = pitch.Pitch('C4') >>> aInterval.pitchStart.nameWithOctave 'G#4' >>> aInterval = interval.Interval('M3') >>> aInterval.pitchEnd = pitch.Pitch('A-3') >>> aInterval.pitchStart.nameWithOctave 'F-3' )rrSs r&rzInterval.pitchEnd/s>~~r%ch|d|_d|_y|j|d}||_||_y)z Assuming that this interval is defined, we can set a new end note (_pitchEnd) and automatically have the start pitch (_pitchStart). NT)rr?)rTr;rs r&rzInterval.pitchEndPsA 9#D !DN $$Q$5!r%c|j}|r|jr |jS|rddlm}|j|Sy)zm Return or set the Note that pitchStart is attached to. For backwards compatibility rr rN)rrr?rNoterTr;rs r&rzInterval.noteStartbs: OO 99   $4991% %r%c:|r|j|_yd|_yrN)rrrTrs r&rzInterval.noteStartqs ggDO"DOr%c|j}|r|jr |jS|rddlm}|j|Sy)zk Return or set the Note that pitchEnd is attached to. For backwards compatibility rr rN)rrr?rrCrDs r&rzInterval.noteEndxs: MM 99   $4991% %r%c:|r|j|_yd|_yrN)rrrFs r&rzInterval.noteEnds GGDM DMr%)NN)rz6t.Union[str, int, float, pitch.Pitch, note.Note, None]rzpitch.Pitch | note.Note | NonerzDiatonicInterval | NonerzChromaticInterval | Nonerpitch.Pitch | NonerrIrnote.Note | pitch.Pitch | NonerrJrYz str | NonerUrpr)rqzDirection | None)rqzSpecifier | NonerTrqrrRr)r;rr'z int | None)r;rr'rQrr)rqrI)r;rIrqNone)r;zmusic21.pitch.Pitch | NonerqrL)rqmusic21.note.Note | None)rrMrqrL)*rrr rrrrrrr~rrYr]rhr-rkr/rprrrtrvrrrrfrrrr r r7rrrrr)rrrWrrrrXrYs@r&rr s|F(,48_E485904.29=7;"&!_E%_E2_E1_E3_E._E,_E7_E5_E  !_EB %!F %%""&&((,,,,00**..0044((((''**,,..;;$$ (55",,.$$,  %12$ b%b'/ bP16 e#.e03e*. eN@6* * X  $@__"""  ##    ^^!!r%cyrNr$r=s r&getWrittenHigherNoterOr%cyrNr$r=s r&rOrOrPr%ct||t|t|}}|j}|j}||kDr|S||kr|St||S)a Given two :class:`~music21.pitch.Pitch` or :class:`~music21.note.Note` objects, this function returns the higher element based on diatonic note numbers. If the diatonic numbers are the same, returns the sounding higher element, or the first element if that is also the same. >>> cis = pitch.Pitch('C#') >>> deses = pitch.Pitch('D--') >>> higher = interval.getWrittenHigherNote(cis, deses) >>> higher is deses True >>> aPitch = pitch.Pitch('c#3') >>> bPitch = pitch.Pitch('d-3') >>> interval.getWrittenHigherNote(aPitch, bPitch) >>> aNote = note.Note('c#3') >>> bNote = note.Note('c3') >>> interval.getWrittenHigherNote(aNote, bNote) is aNote True )r@rr:getAbsoluteHigherNoter>r?rrnum1num2s r&rOrOs\4ue$mE&:R  D  D d{  $UE22r%cyrNr$r=s r&rSrSrPr%cyrNr$r=s r&rSrSrPr%cjt||t||}|j}|dkDr|S|dkr|S|S)aq Given two :class:`~music21.pitch.Pitch` or :class:`~music21.note.Note` objects, returns the higher element based on sounding pitch. If both sounding pitches are the same, returns the first element given. >>> aNote = note.Note('c#3') >>> bNote = note.Note('d--3') >>> interval.getAbsoluteHigherNote(aNote, bNote) rr@rrr>r?rrs r&rSrSBu .I##I1} Q  r%cyrNr$r=s r&getWrittenLowerNoter^rPr%cyrNr$r=s r&r^r^rPr%ct||t|t|}}|j}|j}||kr|S||kDr|St||S)a Given two :class:`~music21.pitch.Pitch` or :class:`~music21.note.Note` objects, returns the lower element based on diatonic note number. If the diatonic number is the same returns the sounding lower element, or the first element if sounding pitch is also the same. >>> aNote = pitch.Pitch('C#3') >>> bNote = pitch.Pitch('D--3') >>> interval.getWrittenLowerNote(aNote, bNote) >>> aNote = pitch.Pitch('C#3') >>> bNote = pitch.Pitch('D-3') >>> interval.getWrittenLowerNote(aNote, bNote) Both elements should be pitches or notes -- if note2 is lower and not the same class as note1 raises a ValueError: >>> aNote = pitch.Pitch('C#4') >>> bNote = note.Note('C#3') >>> interval.getWrittenLowerNote(aNote, bNote) Traceback (most recent call last): ValueError: note1 and note2 must both be notes or pitches )r@rr:getAbsoluteLowerNoterTs r&r^r^s\<ue$mE&:R  D  D d{  #E511r%cyrNr$r=s r&rara!rPr%cyrNr$r=s r&rara'rPr%cjt||t||}|j}|dkDr|S|dkr|S|S)al Given two :class:`~music21.note.Note` or :class:`~music21.pitch.Pitch` objects, returns the lower element based on actual pitch. If both pitches are the same, returns the first element given. >>> aNote = pitch.Pitch('c#3') >>> bNote = pitch.Pitch('d--3') >>> interval.getAbsoluteLowerNote(aNote, bNote) rrZr[s r&rara.r\r%Frct|ttfr t|}n.t |ds"t d|j jz|j||S)a DEPRECATED: call `p.transpose(interval1)` directly Given a :class:`~music21.pitch.Pitch` and a :class:`~music21.interval.Interval` object (Not another class such as ChromaticInterval) or a string such as 'P5' or a number such as 6 (=tritone), return a new Pitch object at the appropriate pitch level. >>> aPitch = pitch.Pitch('C4') >>> P5 = interval.Interval('P5') >>> bPitch = interval.transposePitch(aPitch, P5) >>> bPitch >>> bInterval = interval.Interval('P-5') >>> cPitch = interval.transposePitch(aPitch, bInterval) >>> cPitch Pitches with implicit octaves should work, >>> dPitch = pitch.Pitch('G') >>> ePitch = interval.transposePitch(dPitch, P5) >>> ePitch Can be done inPlace as well >>> C4 = pitch.Pitch('C4') >>> interval.transposePitch(C4, P5, inPlace=True) >>> C4 * Changed in v6: added inPlace parameter. rz8interval must be a music21.interval.Interval object not r) rrOrQrr;rhrrr)r interval1rs r&rrFsdV)c3Z(Y' y"23#J%%../   # #FG # <>> aNote = note.Note('c4') >>> bNote = interval.transposeNote(aNote, 'p5') >>> bNote >>> bNote.pitch >>> aNote = note.Note('f#4') >>> bNote = interval.transposeNote(aNote, 'm2') >>> bNote )rrrrrr)r>intervalStringintvrrs r&rr|sK, nh /'""5;;/HmmE"GGM Nr%ct||S)a Soon to be DEPRECATED: Call Interval Directly Given two :class:`~music21.note.Note` objects, returns an :class:`~music21.interval.Interval` object. The same functionality is available by calling the Interval class with two Notes as arguments. >>> aNote = note.Note('c4') >>> bNote = note.Note('g5') >>> aInterval = interval.notesToInterval(aNote, bNote) >>> aInterval r<)r)rrs r&notesToIntervalrks b" --r%cddlm}|s td|jd}|jd}|D]}t ||}t ||S)aG Add a list of intervals and return the composite interval Intervals can be Interval objects or just strings. (Currently not particularly efficient for large lists) >>> A2 = interval.Interval('A2') >>> P5 = interval.Interval('P5') >>> interval.add([A2, P5]) >>> interval.add([P5, 'm2']) >>> interval.add(['W', 'W', 'H', 'W', 'W', 'W', 'H']) Direction does matter: >>> interval.add([P5, 'P-4']) rr$Cannot add an empty set of intervalsC4r<)r?rrhrrr) intervalListrrrrs r&addrpsY,  FGG T B T B  B " b" --r%c<ddlm}|s td|jd}|jd}t |D]K\}}|dk(r t ||}t |ds t|}n|}t ||j}Mt||S)a Starts with the first interval and subtracts the following intervals from it: >>> interval.subtract(['P5', 'M3']) >>> interval.subtract(['P4', 'd3']) >>> m2Object = interval.Interval('m2') >>> interval.subtract(['M6', 'm2', m2Object]) >>> interval.subtract(['P4', 'M-2']) >>> interval.subtract(['A2', 'A2']) >>> interval.subtract(['A1', 'P1']) >>> interval.subtract(['P8', 'P1']) >>> interval.subtract(['P8', 'd2']) >>> interval.subtract(['P8', 'A1']) >>> a = interval.subtract(['P5', 'A5']) >>> a.niceName 'Diminished Unison' >>> a.directedNiceName 'Descending Diminished Unison' >>> a.chromatic.semitones -1 rrrmrnrr<) r?rrhrrrr;rr)rorrrrintIrs r&subtractrssH  FGG T B T B\*4 6D)B4-&tn " K$7$7$9:B+ b" --r%__main__)r>note.Note | pitch.Pitchr?rurqrL)rrurqr)rrQrqztuple[StepName, int])rRzstr | int | SpecifierrqrB)rRrQrqrQ)rrrqztuple[Specifier, int, float])rrrqztuple[Specifier, int])rrrqr)rRrOrqz0tuple[DiatonicInterval, ChromaticInterval, bool])rpitch.Pitch | note.Noterrvrqr)rrvrrvrqr)rrrrrqrB)rrrrrqrN)rzGenericInterval | intrzChromaticInterval | int | floatrqr)r>rr?rurqr)r>rr?rurqr)r>rur?rurqru)rrrfstr | Intervalrqr)r>rrhrwrqrrK)^rr __future__r fractionsrrrenumrtypingrrr?rrmusic21.common.decoratorsrmusic21.common.typesr r r rr rr Environment environLocalrrIntEnumrr!r"r#rr\rPr@rBr}r{ryrwrsrvrxrzr|rnrrurtrrr_P_m_MrMusic21Exceptionrhrrrrrrrrr Music21ObjectrrrNrrrrrrrrrOrSr^rarrrkrprs _DOC_ORDERrmainTestr$r%r&rs # 1) ??'{&&z2 #F E  && ##Y%%{4U [ _kU kU`              OO OO          ____Gb!Wr1gAwQ"a9;O;OQR:SGb!Wr1gAwQ  55  2,33jGIR=@2> 2>!2>j&"R?A;@B-N("4%%("VT 1lT 1n{ |{ | F O9 O95O9d$$$$8,,,,2? ? ??D- - --&34 34 %3434xX!|X!x  5'    5)  $3 5$33$3P !6(   !6*  !640 4&   4(  (24(22(2V  5'    5)   538  3= 3=3=  3=l$)2B.$.B4.x 3-  zGr%