music21.voiceLeading

Objects to represent unique elements in a score that contain special analysis routines to identify certain aspects of music theory. for use especially with theoryAnalyzer, which will divide a score up into these segments, returning a list of segments to later analyze

The list of objects included here are:

• VoiceLeadingQuartet : two by two matrix of notes

• Verticalityvertical context in a score,

  composed of any music21 objects

• VerticalityNTupletgroup of three

  contiguous verticality objects

• VerticalityTripletthree verticality objects –

  has special features

• NObjectLinearSegment : n (any number) of music21 objects

• NNoteLinearSegment : n (any number) of notes

• ThreeNoteLinearSegment : three notes in the same part of a score

• NChordLinearSegment :

  preliminary implementation of n(any number) chords

• TwoChordLinearSegment : 2 chord objects

VoiceLeadingQuartet

class music21.voiceLeading.VoiceLeadingQuartet(v1n1=None, v1n2=None, v2n1=None, v2n2=None, analyticKey=None)

An object consisting of four pitches: v1n1, v1n2, v2n1, v2n2 where v1n1 moves to v1n2 at the same time as v2n1 moves to v2n2. (v1n1: voice 1(top voice), note 1 (left most note) )

Necessary for classifying types of voice-leading motion.

In general, v1 should be the “higher” voice and v2 the “lower” voice in order for methods such as .voiceCrossing and isProperResolution to make sense. Most routines will work the other way still though.

VoiceLeadingQuartet bases

• Music21Object

• ProtoM21Object

VoiceLeadingQuartet read-only properties

Read-only properties inherited from Music21Object:

beat beatDuration beatStr

beatStrength hasEditorialInformation

hasStyleInformation measureNumber

Read-only properties inherited from ProtoM21Object:

classSet

classes

VoiceLeadingQuartet read/write properties

VoiceLeadingQuartet.key

get or set the key of this VoiceLeadingQuartet, for use in theory analysis routines such as closesIncorrectly. Can be None

>>> vlq = voiceLeading.VoiceLeadingQuartet('D', 'G', 'B', 'G')
>>> vlq.key is None
True
>>> vlq.key = key.Key('G')
>>> vlq.key
<music21.key.Key of G major>

Key can also be given as a string:

>>> vlq.key = 'd'
>>> vlq.key
<music21.key.Key of d minor>

Incorrect keys raise VoiceLeadingQuartetExceptions

VoiceLeadingQuartet.v1n1

set note1 for voice 1

>>> vl = voiceLeading.VoiceLeadingQuartet('C', 'D', 'E', 'F')
>>> vl.v1n1
<music21.note.Note C>

VoiceLeadingQuartet.v1n2

set note 2 for voice 1

>>> vl = voiceLeading.VoiceLeadingQuartet('C', 'D', 'E', 'F')
>>> vl.v1n2
<music21.note.Note D>

VoiceLeadingQuartet.v2n1

set note 1 for voice 2

>>> vl = voiceLeading.VoiceLeadingQuartet('C', 'D', 'E', 'F')
>>> vl.v2n1
<music21.note.Note E>

VoiceLeadingQuartet.v2n2

set note 2 for voice 2

>>> vl = voiceLeading.VoiceLeadingQuartet('C', 'D', 'E', 'F')
>>> vl.v2n2
<music21.note.Note F>

Read/write properties inherited from Music21Object:

activeSite derivation duration editorial

id offset priority

quarterLength seconds style

VoiceLeadingQuartet methods

VoiceLeadingQuartet.antiParallelMotion(simpleName=None) → bool

Returns True if the simple interval before is the same as the simple interval after and the motion is contrary. if simpleName is specified as an Interval object or a string then it only returns true if the simpleName of both intervals is the same as simpleName (i.e., use to find antiParallel fifths)

>>> n11 = note.Note('C4')
>>> n12 = note.Note('D3')  # descending 7th
>>> n21 = note.Note('G4')
>>> n22 = note.Note('A4')  # ascending 2nd
>>> vlq1 = voiceLeading.VoiceLeadingQuartet(n11, n12, n21, n22)
>>> vlq1.antiParallelMotion()
True

>>> vlq1.antiParallelMotion('M2')
False

>>> vlq1.antiParallelMotion('P5')
True

We can also use interval objects

>>> p5Obj = interval.Interval('P5')
>>> p8Obj = interval.Interval('P8')
>>> vlq1.antiParallelMotion(p5Obj)
True

>>> p8Obj = interval.Interval('P8')
>>> vlq1.antiParallelMotion(p8Obj)
False

>>> n1 = note.Note('G4')
>>> n2 = note.Note('G4')
>>> m1 = note.Note('G4')
>>> m2 = note.Note('G3')
>>> vl2 = voiceLeading.VoiceLeadingQuartet(n1, n2, m1, m2)
>>> vl2.antiParallelMotion()
False

VoiceLeadingQuartet.closesIncorrectly() → bool

TODO(msc): will be renamed to be less dogmatic

Returns True if the VLQ would be an incorrect closing in the style of 16th century Counterpoint (not Bach Chorale style)

Returns True if closing harmonic interval is a P8 or PU and the interval approaching the close is 6 - 8, 10 - 8, or 3 - U. Must be in contrary motion, and if in minor key, has a leading tone resolves to the tonic.

>>> vl = voiceLeading.VoiceLeadingQuartet('C#', 'D', 'E', 'D')
>>> vl.key = key.Key('d')
>>> vl.closesIncorrectly()
False
>>> vl = voiceLeading.VoiceLeadingQuartet('B3', 'C4', 'G3', 'C2')
>>> vl.key = key.Key('C')
>>> vl.closesIncorrectly()
False
>>> vl = voiceLeading.VoiceLeadingQuartet('F', 'G', 'D', 'G')
>>> vl.key = key.Key('g')
>>> vl.closesIncorrectly()
True
>>> vl = voiceLeading.VoiceLeadingQuartet('C#4', 'D4', 'A2', 'D3', analyticKey='D')
>>> vl.closesIncorrectly()
True

VoiceLeadingQuartet.contraryMotion() → bool

Returns True if both voices move in opposite directions

>>> n1 = note.Note('G4')
>>> n2 = note.Note('G4')
>>> m1 = note.Note('G4')
>>> m2 = note.Note('G4')

No motion, so False:

>>> vl = voiceLeading.VoiceLeadingQuartet(n1, n2, m1, m2)
>>> vl.contraryMotion()
False

Oblique motion, so False:

>>> n2.octave = 5
>>> vl = voiceLeading.VoiceLeadingQuartet(n1, n2, m1, m2)
>>> vl.contraryMotion()
False

Parallel motion, so False

>>> m2.octave = 5
>>> vl = voiceLeading.VoiceLeadingQuartet(n1, n2, m1, m2)
>>> vl.contraryMotion()
False

Similar motion, so False

>>> m2 = note.Note('A5')
>>> vl = voiceLeading.VoiceLeadingQuartet(n1, n2, m1, m2)
>>> vl.contraryMotion()
False

Finally, contrary motion, so True!

>>> m2 = note.Note('C4')
>>> vl = voiceLeading.VoiceLeadingQuartet(n1, n2, m1, m2)
>>> vl.contraryMotion()
True

VoiceLeadingQuartet.hiddenFifth() → bool

Calls hiddenInterval() by passing a fifth

VoiceLeadingQuartet.hiddenInterval(thisInterval) → bool

Returns True if there is a hidden interval that matches thisInterval.

N.B. – this method finds ALL hidden intervals, not just those that are forbidden under traditional common practice counterpoint rules. Takes thisInterval, an Interval object.

>>> n1 = note.Note('C4')
>>> n2 = note.Note('G4')
>>> m1 = note.Note('B4')
>>> m2 = note.Note('D5')
>>> vl = voiceLeading.VoiceLeadingQuartet(n1, n2, m1, m2)
>>> vl.hiddenInterval(interval.Interval('P5'))
True

>>> n1 = note.Note('E4')
>>> n2 = note.Note('G4')
>>> m1 = note.Note('B4')
>>> m2 = note.Note('D5')
>>> vl = voiceLeading.VoiceLeadingQuartet(n1, n2, m1, m2)
>>> vl.hiddenInterval(interval.Interval('P5'))
False

>>> n1 = note.Note('E4')
>>> n2 = note.Note('G4')
>>> m1 = note.Note('B4')
>>> m2 = note.Note('D6')
>>> vl = voiceLeading.VoiceLeadingQuartet(n1, n2, m1, m2)
>>> vl.hiddenInterval(interval.Interval('P5'))
False

VoiceLeadingQuartet.hiddenOctave() → bool

Calls hiddenInterval by passing an octave

VoiceLeadingQuartet.inwardContraryMotion() → bool

Returns True if both voices move inward by contrary motion

>>> n1 = note.Note('C5')
>>> n2 = note.Note('B4')
>>> m1 = note.Note('G4')
>>> m2 = note.Note('A4')
>>> vl = voiceLeading.VoiceLeadingQuartet(n1, n2, m1, m2)
>>> vl.inwardContraryMotion()
True
>>> vl.outwardContraryMotion()
False

VoiceLeadingQuartet.isProperResolution() → bool

Checks whether the voice-leading quartet resolves correctly according to standard counterpoint rules. If the first harmony is dissonant (P4, d5, A4, or m7) it checks that these are correctly resolved. If the first harmony is consonant, True is returned.

The key parameter should be specified to check for motion in the bass from specific note degrees. If it is not set, then no checking for scale degrees takes place.

Currently implements the following resolutions:

P4: Top voice must resolve downward.

A4: out by contrary motion to a sixth, with chordal seventh resolving

down to a third in the bass.

d5: in by contrary motion to a third, with 7 resolving up to 1 in the bass

m7: Resolves to a third with a leap from 5 to 1 in the bass

We will make the examples shorter with this abbreviation: >>> N = note.Note

>>> n1 = note.Note('B-4')
>>> n2 = note.Note('A4')
>>> m1 = note.Note('E4')
>>> m2 = note.Note('F4')
>>> vl = voiceLeading.VoiceLeadingQuartet(n1, n2, m1, m2)
>>> vl.isProperResolution()  # d5 resolves inward
True
>>> m2.pitch.name = 'D'
>>> vl = voiceLeading.VoiceLeadingQuartet(n1, n2, m1, m2)
>>> vl.isProperResolution()  # d5 resolves outward
False
>>> vl.key = 'B-'
>>> vl.isProperResolution()  # not on scale degrees that need resolution
True

>>> n1 = note.Note('D4')
>>> n2 = note.Note('C4')
>>> m1 = note.Note('G#3')
>>> m2 = note.Note('A3')
>>> k = key.Key('a')
>>> vl = voiceLeading.VoiceLeadingQuartet(n1, n2, m1, m2, k)
>>> vl.isProperResolution()  # d5 with #7 in minor handled correctly
True

>>> n1 = note.Note('E5')
>>> n2 = note.Note('F5')
>>> m1 = note.Note('B-4')
>>> m2 = note.Note('A4')
>>> vl = voiceLeading.VoiceLeadingQuartet(n1, n2, m1, m2)
>>> vl.isProperResolution()  # A4 resolves outward
True
>>> m2.pitch.nameWithOctave = 'D5'
>>> vl = voiceLeading.VoiceLeadingQuartet(n1, n2, m1, m2)
>>> vl.isProperResolution()  # A4 resolves inward
False
>>> vl.key = 'B-'
>>> vl.isProperResolution()  # A4 not on scale degrees that need resolution
True
>>> vl.key = 'F'
>>> vl.isProperResolution()  # A4 on scale degrees that need resolution
False

>>> n1 = note.Note('B-4')
>>> n2 = note.Note('A4')
>>> m1 = note.Note('C4')
>>> m2 = note.Note('F4')
>>> vl = voiceLeading.VoiceLeadingQuartet(n1, n2, m1, m2)
>>> vl.isProperResolution()  # m7
True
>>> m2.pitch.nameWithOctave = 'F3'
>>> vl = voiceLeading.VoiceLeadingQuartet(n1, n2, m1, m2)
>>> vl.isProperResolution()  # m7 with similar motion
True
>>> vl.key = 'B-'
>>> vl.isProperResolution()  # m7 not on scale degrees that need resolution
True
>>> vl.key = 'F'
>>> vl.isProperResolution()  # m7 on scale degrees that need resolution
True

P4 on the initial harmony must move down.

>>> n1 = note.Note('F5')
>>> n2 = note.Note('G5')
>>> m1 = note.Note('C4')
>>> m2 = note.Note('C4')
>>> vl = voiceLeading.VoiceLeadingQuartet(n1, n2, m1, m2)
>>> vl.isProperResolution()  # P4 must move down or remain static
False
>>> n2.step = 'E'
>>> vl = voiceLeading.VoiceLeadingQuartet(n1, n2, m1, m2)
>>> vl.isProperResolution()  # P4 can move down by step or leap
True

>>> vl = voiceLeading.VoiceLeadingQuartet('B-4', 'A4', 'C2', 'F2')
>>> vl.key = key.Key('F')
>>> vl.isProperResolution()  # not dissonant, True returned
True

VoiceLeadingQuartet.leapNotSetWithStep() → bool

Returns True if there is a leap or skip in once voice then the other voice must be a step or unison. if neither part skips then False is returned. Returns False if the two voices skip thirds in contrary motion.

>>> n1 = note.Note('G4')
>>> n2 = note.Note('C5')
>>> m1 = note.Note('B3')
>>> m2 = note.Note('A3')
>>> vl = voiceLeading.VoiceLeadingQuartet(n1, n2, m1, m2)
>>> vl.leapNotSetWithStep()
False

>>> n1 = note.Note('G4')
>>> n2 = note.Note('C5')
>>> m1 = note.Note('B3')
>>> m2 = note.Note('F3')
>>> vl = voiceLeading.VoiceLeadingQuartet(n1, n2, m1, m2)
>>> vl.leapNotSetWithStep()
True

>>> vl = voiceLeading.VoiceLeadingQuartet('E', 'G', 'G', 'E')
>>> vl.leapNotSetWithStep()
False

VoiceLeadingQuartet.motionType(*, allowAntiParallel=False)

returns the type of motion from the MotionType Enum object that exists in this voice leading quartet

>>> for mt in voiceLeading.MotionType:
...     print(repr(mt))
<MotionType.antiParallel: 'Anti-Parallel'>
<MotionType.contrary: 'Contrary'>
<MotionType.noMotion: 'No Motion'>
<MotionType.oblique: 'Oblique'>
<MotionType.parallel: 'Parallel'>
<MotionType.similar: 'Similar'>

>>> n1_d4 = note.Note('D4')
>>> n2_e4 = note.Note('E4')
>>> m1_f4 = note.Note('F4')
>>> m2_b4 = note.Note('B4')
>>> vl = voiceLeading.VoiceLeadingQuartet(n1_d4, n2_e4, m1_f4, m2_b4)
>>> vl.motionType()
<MotionType.similar: 'Similar'>

>>> n1_a4 = note.Note('A4')
>>> n2_c5 = note.Note('C5')
>>> m1_d4 = note.Note('D4')
>>> m2_f4 = note.Note('F4')
>>> vl = voiceLeading.VoiceLeadingQuartet(n1_a4, n2_c5, m1_d4, m2_f4)
>>> vl.motionType()
<MotionType.parallel: 'Parallel'>
>>> print(vl.motionType())
MotionType.parallel
>>> vl.motionType() == 'Parallel'
True

Demonstrations of other motion types.

Contrary:

>>> n1_d5 = note.Note('D5')   # D5, C5 against D4, F4
>>> vl = voiceLeading.VoiceLeadingQuartet(n1_d5, n2_c5, m1_d4, m2_f4)
>>> vl.motionType()
<MotionType.contrary: 'Contrary'>

Oblique:

>>> n1_c5 = note.Note('C5')   # C5, C5 against D4, F4
>>> vl = voiceLeading.VoiceLeadingQuartet(n1_c5, n2_c5, m1_d4, m2_f4)
>>> vl.motionType()
<MotionType.oblique: 'Oblique'>

No motion (if I had a dollar for every time I forgot to teach that this is not a form of oblique motion…):

>>> m1_f4 = note.Note('F4')   # C5, C5 against F4, F4
>>> vl = voiceLeading.VoiceLeadingQuartet(n1_c5, n2_c5, m1_f4, m2_f4)
>>> vl.motionType()
<MotionType.noMotion: 'No Motion'>

Anti-parallel motion has to be explicitly enabled to appear:

>>> n1_a5 = note.Note('A5')
>>> vl = voiceLeading.VoiceLeadingQuartet(n1_a5, n2_c5, m1_d4, m2_f4)
>>> vl.motionType()  # anti-parallel fifths
<MotionType.contrary: 'Contrary'>
>>> vl.motionType(allowAntiParallel=True)
<MotionType.antiParallel: 'Anti-Parallel'>

Changed in v.6 – anti-parallel motion was supposed to be able to be returned in previous versions, but a bug prevented it. To preserve backwards compatibility, it must be explicitly enabled.

VoiceLeadingQuartet.noMotion() → bool

Returns True if no voice moves in this “voice-leading” moment

>>> n1 = note.Note('G4')
>>> n2 = note.Note('G4')
>>> m1 = note.Note('D4')
>>> m2 = note.Note('D4')
>>> vl = voiceLeading.VoiceLeadingQuartet(n1, n2, m1, m2)
>>> vl.noMotion()
True
>>> n2.octave = 5
>>> vl = voiceLeading.VoiceLeadingQuartet(n1, n2, m1, m2)
>>> vl.noMotion()
False

VoiceLeadingQuartet.obliqueMotion() → bool

Returns True if one voice remains the same and another moves. i.e., noMotion must be False if obliqueMotion is True.

>>> n1 = note.Note('G4')
>>> n2 = note.Note('G4')
>>> m1 = note.Note('D4')
>>> m2 = note.Note('D4')
>>> vl = voiceLeading.VoiceLeadingQuartet(n1, n2, m1, m2)
>>> vl.obliqueMotion()
False
>>> n2.octave = 5
>>> vl = voiceLeading.VoiceLeadingQuartet(n1, n2, m1, m2)
>>> vl.obliqueMotion()
True
>>> m2.octave = 5
>>> vl = voiceLeading.VoiceLeadingQuartet(n1, n2, m1, m2)
>>> vl.obliqueMotion()
False

VoiceLeadingQuartet.opensIncorrectly() → bool

TODO(msc): will be renamed to be less dogmatic

Returns True if the VLQ would be an incorrect opening in the style of 16th century Counterpoint (not Bach Chorale style)

Returns True if the opening or second harmonic interval is PU, P8, or P5, to accommodate an anacrusis. also checks to see if opening establishes tonic or dominant harmony (uses identifyAsTonicOrDominant()

>>> vl = voiceLeading.VoiceLeadingQuartet('D', 'D', 'D', 'F#')
>>> vl.key = 'D'
>>> vl.opensIncorrectly()
False
>>> vl = voiceLeading.VoiceLeadingQuartet('B', 'A', 'G#', 'A')
>>> vl.key = 'A'
>>> vl.opensIncorrectly()
False
>>> vl = voiceLeading.VoiceLeadingQuartet('A', 'A', 'F#', 'D')
>>> vl.key = 'A'
>>> vl.opensIncorrectly()
False

>>> vl = voiceLeading.VoiceLeadingQuartet('C#', 'C#', 'D', 'E')
>>> vl.key = 'A'
>>> vl.opensIncorrectly()
True

>>> vl = voiceLeading.VoiceLeadingQuartet('B', 'B', 'A', 'A')
>>> vl.key = 'C'
>>> vl.opensIncorrectly()
True

VoiceLeadingQuartet.outwardContraryMotion() → bool

Returns True if both voices move outward by contrary motion

>>> n1 = note.Note('D5')
>>> n2 = note.Note('E5')
>>> m1 = note.Note('G4')
>>> m2 = note.Note('F4')
>>> vl = voiceLeading.VoiceLeadingQuartet(n1, n2, m1, m2)
>>> vl.outwardContraryMotion()
True
>>> vl.inwardContraryMotion()
False

VoiceLeadingQuartet.parallelFifth() → bool

Returns True if the motion is a parallel or antiparallel Perfect Fifth, allowing displacement by an octave (e.g., 5th to a 12th).

We will make the examples shorter with this abbreviation:

>>> N = note.Note

Parallel fifths

>>> vlq = voiceLeading.VoiceLeadingQuartet(N('G4'), N('A4'), N('C4'), N('D4'))
>>> vlq.parallelFifth()
True

5th -> 12th in similar motion

>>> vlq = voiceLeading.VoiceLeadingQuartet(N('G4'), N('A5'), N('C4'), N('D4'))
>>> vlq.parallelFifth()
True

5th -> 12th in antiparallel motion

>>> vlq = voiceLeading.VoiceLeadingQuartet(N('G4'), N('A4'), N('C4'), N('D3'))
>>> vlq.parallelFifth()
True

Note that diminished fifth moving to perfect fifth is not a parallelFifth

>>> vlq = voiceLeading.VoiceLeadingQuartet(N('G4'), N('A4'), N('C#4'), N('D4'))
>>> vlq.parallelFifth()
False

Nor is P5 moving to d5.

>>> vlq = voiceLeading.VoiceLeadingQuartet(N('G4'), N('Ab4'), N('C4'), N('D4'))
>>> vlq.parallelFifth()
False

VoiceLeadingQuartet.parallelInterval(thisInterval) → bool

Returns True if there is a parallel motion or antiParallel motion of this type (thisInterval should be an Interval object)

>>> n11 = note.Note('G4')
>>> n12a = note.Note('A4')  # ascending 2nd

>>> n21 = note.Note('C4')
>>> n22a = note.Note('D4')  # ascending 2nd

>>> vlq1 = voiceLeading.VoiceLeadingQuartet(n11, n12a, n21, n22a)
>>> vlq1.parallelInterval(interval.Interval('P5'))
True

>>> vlq1.parallelInterval(interval.Interval('P8'))
False

Antiparallel fifths also are True

>>> n22b = note.Note('D3')  # descending 7th
>>> vlq2 = voiceLeading.VoiceLeadingQuartet(n11, n12a, n21, n22b)
>>> vlq2.parallelInterval(interval.Interval('P5'))
True

But Antiparallel other interval are not:

>>> N = note.Note
>>> vlq2a = voiceLeading.VoiceLeadingQuartet(N('C5'), N('C6'), N('C4'), N('C3'))
>>> vlq2a.parallelInterval(interval.Interval('P5'))
False
>>> vlq2a.parallelInterval(interval.Interval('P8'))
True

Non-parallel intervals are, of course, False

>>> n12b = note.Note('B4')  # ascending 3rd
>>> vlq3 = voiceLeading.VoiceLeadingQuartet(n11, n12b, n21, n22b)
>>> vlq3.parallelInterval(interval.Interval('P5'))
False

VoiceLeadingQuartet.parallelMotion(requiredInterval=None, allowOctaveDisplacement=False) → bool

Returns True if both the first and second intervals are the same sized generic interval.

If requiredInterval is set, returns True only if both intervals are that generic or specific interval.

allowOctaveDisplacement treats motion as parallel even if any of the intervals are displaced by octaves, except in the case of unisons and octaves, which are always treated as distinct.

We will make the examples shorter with this abbreviation: >>> N = note.Note

>>> vl = voiceLeading.VoiceLeadingQuartet(N('G4'), N('G4'), N('G3'), N('G3'))
>>> vl.parallelMotion()  # not even similar motion
False

>>> vl = voiceLeading.VoiceLeadingQuartet(N('G4'), N('B4'), N('G3'), N('A3'))
>>> vl.parallelMotion()  # similar motion, but no kind of parallel
False

>>> vl = voiceLeading.VoiceLeadingQuartet(N('G4'), N('G5'), N('G4'), N('G5'))
>>> vl.parallelMotion()  # parallel unisons
True

>>> vl.parallelMotion('P1')
True

octaves never equivalent to unisons

>>> vl.parallelMotion('P8', allowOctaveDisplacement=True)
False

>>> vl = voiceLeading.VoiceLeadingQuartet(N('A4'), N('B4'), N('D3'), N('E3'))
>>> vl.parallelMotion()  # parallel fifths
True

>>> vl = voiceLeading.VoiceLeadingQuartet(N('A4'), N('B5'), N('D3'), N('E3'))
>>> vl.parallelMotion()  # 5th to a 12th
False
>>> vl.parallelMotion(allowOctaveDisplacement=True)
True

>>> vl = voiceLeading.VoiceLeadingQuartet(N('A4'), N('Bb4'), N('F4'), N('G4'))
>>> vl.parallelMotion(3)  # parallel thirds ...
True
>>> vl.parallelMotion('M3')  # ... but not parallel MAJOR thirds
False

>>> vl = voiceLeading.VoiceLeadingQuartet(N('D4'), N('E4'), N('F3'), N('G3'))
>>> gi = interval.GenericInterval(6)
>>> vl.parallelMotion(gi)  # these are parallel sixths ...
True

These are also parallel major sixths

>>> i = interval.Interval('M6')
>>> di = interval.DiatonicInterval('major', 6)
>>> vl.parallelMotion(i) and vl.parallelMotion(di)
True

>>> vl = voiceLeading.VoiceLeadingQuartet(N('D5'), N('E6'), N('F3'), N('G3'))
>>> vl.parallelMotion(gi)  # octave displacement
False
>>> vl.parallelMotion(gi, allowOctaveDisplacement=True)
True

VoiceLeadingQuartet.parallelOctave() → bool

Returns True if the motion is a parallel Perfect Octave… a concept so abhorrent we shudder to illustrate it with an example, but alas, we must:

We will make the examples shorter with this abbreviation: >>> N = note.Note

>>> vlq = voiceLeading.VoiceLeadingQuartet(N('C5'), N('D5'), N('C4'), N('D4'))
>>> vlq.parallelOctave()
True

>>> vlq = voiceLeading.VoiceLeadingQuartet(N('C6'), N('D6'), N('C4'), N('D4'))
>>> vlq.parallelOctave()
True

Or False if the motion is according to the rules of God’s own creation:

>>> vlq = voiceLeading.VoiceLeadingQuartet(N('C4'), N('D4'), N('C4'), N('D4'))
>>> vlq.parallelOctave()
False

VoiceLeadingQuartet.parallelUnison() → bool

Returns True if the motion is a parallel Perfect Unison (and not Perfect Octave, etc.)

We will make the examples shorter with this abbreviation:

>>> N = note.Note
>>> vlq = voiceLeading.VoiceLeadingQuartet(N('C4'), N('D4'), N('C4'), N('D4'))
>>> vlq.parallelUnison()
True

>>> vlq  = voiceLeading.VoiceLeadingQuartet(N('C5'), N('D5'), N('C4'), N('D4'))
>>> vlq.parallelUnison()
False

VoiceLeadingQuartet.parallelUnisonOrOctave() → bool

Returns True if the VoiceLeadingQuartet has motion by parallel octave or parallel unison

>>> voiceLeading.VoiceLeadingQuartet(
...     note.Note('C4'),
...     note.Note('D4'),
...     note.Note('C3'),
...     note.Note('D3')
...     ).parallelUnisonOrOctave()
True

>>> voiceLeading.VoiceLeadingQuartet(
...     note.Note('C4'),
...     note.Note('D4'),
...     note.Note('C4'),
...     note.Note('D4')
...     ).parallelUnisonOrOctave()
True

VoiceLeadingQuartet.similarMotion() → bool

Returns True if the two voices both move in the same direction. Parallel Motion will also return true, as it is a special case of similar motion. If there is no motion, returns False.

>>> n1 = note.Note('G4')
>>> n2 = note.Note('G4')
>>> m1 = note.Note('G4')
>>> m2 = note.Note('G4')
>>> vl = voiceLeading.VoiceLeadingQuartet(n1, n2, m1, m2)
>>> vl.similarMotion()
False
>>> n2.octave = 5
>>> vl = voiceLeading.VoiceLeadingQuartet(n1, n2, m1, m2)
>>> vl.similarMotion()
False
>>> m2.octave = 5
>>> vl = voiceLeading.VoiceLeadingQuartet(n1, n2, m1, m2)
>>> vl.similarMotion()
True
>>> m2 = note.Note('A5')
>>> vl = voiceLeading.VoiceLeadingQuartet(n1, n2, m1, m2)
>>> vl.similarMotion()
True

VoiceLeadingQuartet.voiceCrossing() → bool

Returns True if either note in V1 is lower than the simultaneous note in V2.

We will make the examples shorter with this abbreviation:

>>> N = note.Note

>>> vl = voiceLeading.VoiceLeadingQuartet(N('A4'), N('A4'), N('G4'), N('G4'))
>>> vl.voiceCrossing()  # nothing crossed
False

>>> vl = voiceLeading.VoiceLeadingQuartet(N('A4'), N('F4'), N('G4'), N('G4'))
>>> vl.voiceCrossing()  # second interval is crossed
True

>>> vl = voiceLeading.VoiceLeadingQuartet(N('F4'), N('A4'), N('G4'), N('G4'))
>>> vl.voiceCrossing()  # first interval crossed
True

>>> vl = voiceLeading.VoiceLeadingQuartet(N('F4'), N('F4'), N('G4'), N('G4'))
>>> vl.voiceCrossing()  # both crossed
True

VoiceLeadingQuartet.voiceOverlap() → bool

Returns True if the second note in V1 is lower than the first in V2, or if the second note in V2 is higher than the first note in V1.

We will make the examples shorter with this abbreviation: >>> N = note.Note

>>> vl = voiceLeading.VoiceLeadingQuartet(N('A4'), N('B4'), N('F4'), N('G4'))
>>> vl.voiceOverlap()  # no overlap
False

>>> vl = voiceLeading.VoiceLeadingQuartet(N('A4'), N('B4'), N('F4'), N('A4'))
>>> vl.voiceOverlap()  # Motion to the SAME note is not considered overlap
False

>>> vl = voiceLeading.VoiceLeadingQuartet(N('A4'), N('C4'), N('F4'), N('Bb4'))
>>> vl.voiceOverlap()  # V2 overlaps V1
True

>>> vl = voiceLeading.VoiceLeadingQuartet(N('A4'), N('E4'), N('F4'), N('D4'))
>>> vl.voiceOverlap()  # V1 overlaps V2
True

Methods inherited from Music21Object:

clearCache() containerHierarchy() contextSites() getAllContextsByClass() getContextByClass() getOffsetBySite() getOffsetInHierarchy()

getSpannerSites() informSites() mergeAttributes() next() previous() purgeLocations() purgeOrphans()

setOffsetBySite() show() sortTuple() splitAtDurations() splitAtQuarterLength() splitByQuarterLengths() write()

Methods inherited from ProtoM21Object:

isClassOrSubclass()

VoiceLeadingQuartet instance variables

VoiceLeadingQuartet.hIntervals

A two-element list of the two melodic intervals present, v1n1 to v1n2 and v2n1 to v2n2.

VoiceLeadingQuartet.vIntervals

A two-element list of the two harmonic intervals present, vn1n1 to v2n1 and v1n2 to v2n2.

Instance variables inherited from Music21Object:

classSortOrder groups

isStream

sites

ThreeNoteLinearSegment

class music21.voiceLeading.ThreeNoteLinearSegment(noteListOrN1=None, n2=None, n3=None)

An object consisting of three sequential notes

The middle tone in a ThreeNoteLinearSegment can be classified using methods enclosed in this class to identify it as types of embellishing tones. Further methods can be used on the entire stream to identify these as non-harmonic.

Accepts a sequence of strings, pitches, or notes.

>>> ex = voiceLeading.ThreeNoteLinearSegment('C#4', 'D4', 'E-4')
>>> ex.n1
<music21.note.Note C#>
>>> ex.n2
<music21.note.Note D>
>>> ex.n3
<music21.note.Note E->

>>> ex = voiceLeading.ThreeNoteLinearSegment(note.Note('A4'),note.Note('D4'),'F5')
>>> ex.n1
<music21.note.Note A>
>>> ex.n2
<music21.note.Note D>
>>> ex.n3
<music21.note.Note F>
>>> ex.iLeftToRight
<music21.interval.Interval m6>

>>> ex.iLeft
<music21.interval.Interval P-5>
>>> ex.iRight
<music21.interval.Interval m10>

if no octave specified, default octave of 4 is assumed

>>> ex2 = voiceLeading.ThreeNoteLinearSegment('a', 'b', 'c')
>>> ex2.n1
<music21.note.Note A>
>>> ex2.n1.pitch.defaultOctave
4

ThreeNoteLinearSegment bases

• NNoteLinearSegment

• Music21Object

• ProtoM21Object

ThreeNoteLinearSegment read-only properties

ThreeNoteLinearSegment.iLeft

get the interval between the left-most note and the middle note (read-only property)

>>> tnls = voiceLeading.ThreeNoteLinearSegment('A', 'B', 'G')
>>> tnls.iLeft
<music21.interval.Interval M2>

ThreeNoteLinearSegment.iLeftToRight

get the interval between the left-most note and the right-most note (read-only property)

>>> tnls = voiceLeading.ThreeNoteLinearSegment('C', 'E', 'G')
>>> tnls.iLeftToRight
<music21.interval.Interval P5>

ThreeNoteLinearSegment.iRight

get the interval between the middle note and the right-most note (read-only property)

>>> tnls = voiceLeading.ThreeNoteLinearSegment('A', 'B', 'G')
>>> tnls.iRight
<music21.interval.Interval M-3>

Read-only properties inherited from NNoteLinearSegment:

melodicIntervals

noteList

Read-only properties inherited from Music21Object:

beat beatDuration beatStr

beatStrength hasEditorialInformation

hasStyleInformation measureNumber

Read-only properties inherited from ProtoM21Object:

classSet

classes

ThreeNoteLinearSegment read/write properties

ThreeNoteLinearSegment.n1

get or set the first note (left-most) in the segment

ThreeNoteLinearSegment.n2

get or set the middle note in the segment

ThreeNoteLinearSegment.n3

get or set the last note (right-most) in the segment

Read/write properties inherited from Music21Object:

activeSite derivation duration editorial

id offset priority

quarterLength seconds style

ThreeNoteLinearSegment methods

ThreeNoteLinearSegment.color(color='red', noteList=(2,))

color all the notes in noteList (1, 2, 3). Default is to color only the second note red

DEPRECATED.

ThreeNoteLinearSegment.couldBeChromaticNeighborTone() → bool

returns True if and only if noteToAnalyze could be a chromatic neighbor tone, that is, the left and right notes are identical while the middle is a chromatic step up or down

>>> voiceLeading.ThreeNoteLinearSegment('C3', 'D3', 'C3').couldBeChromaticNeighborTone()
False
>>> voiceLeading.ThreeNoteLinearSegment('C3', 'D-3', 'C3').couldBeChromaticNeighborTone()
True
>>> voiceLeading.ThreeNoteLinearSegment('C#3', 'D3', 'C#3').couldBeChromaticNeighborTone()
True
>>> voiceLeading.ThreeNoteLinearSegment('C#3', 'D3', 'D-3').couldBeChromaticNeighborTone()
False

ThreeNoteLinearSegment.couldBeChromaticPassingTone()

A note could a chromatic passing tone (and therefore a passing tone in general) if the generic interval between the previous and the current is -2, 1, or 2; the generic interval between the current and next is -2, 1, 2; the two generic intervals multiply to -2 or 2 (if 4 then it’s a diatonic interval; if 1 then not a passing tone; i.e, C -> C# -> C## is not a chromatic passing tone); AND between each of the notes there is a chromatic interval of 1 or -1 and multiplied together it is 1. (i.e.: C -> D– -> D- is not a chromatic passing tone).

>>> voiceLeading.ThreeNoteLinearSegment('B3', 'C4', 'C#4').couldBeChromaticPassingTone()
True
>>> voiceLeading.ThreeNoteLinearSegment('B3', 'C4', 'C#4').couldBeChromaticPassingTone()
True
>>> voiceLeading.ThreeNoteLinearSegment('B3', 'B#3', 'C#4').couldBeChromaticPassingTone()
True
>>> voiceLeading.ThreeNoteLinearSegment('B3', 'D-4', 'C#4').couldBeChromaticPassingTone()
False
>>> voiceLeading.ThreeNoteLinearSegment('B3', 'C##4', 'C#4').couldBeChromaticPassingTone()
False
>>> voiceLeading.ThreeNoteLinearSegment('C#4', 'C4', 'C##4').couldBeChromaticPassingTone()
False
>>> voiceLeading.ThreeNoteLinearSegment('D--4', 'C4', 'D-4').couldBeChromaticPassingTone()
False

ThreeNoteLinearSegment.couldBeDiatonicNeighborTone() → bool

Returns True if and only if noteToAnalyze could be a diatonic neighbor tone, that is, the left and right notes are identical while the middle is a diatonic step up or down

>>> voiceLeading.ThreeNoteLinearSegment('C3', 'D3', 'C3').couldBeDiatonicNeighborTone()
True
>>> voiceLeading.ThreeNoteLinearSegment('C3', 'C#3', 'C3').couldBeDiatonicNeighborTone()
False
>>> voiceLeading.ThreeNoteLinearSegment('C3', 'D-3', 'C3').couldBeDiatonicNeighborTone()
False

ThreeNoteLinearSegment.couldBeDiatonicPassingTone()

A note could be a diatonic passing tone (and therefore a passing tone in general) if the generic interval between the previous and the current is 2 or -2; same for the next; and both move in the same direction (that is, the two intervals multiplied by each other are 4, not -4).

>>> tls = voiceLeading.ThreeNoteLinearSegment('B3', 'C4', 'C#4')
>>> tls.couldBeDiatonicPassingTone()
False

>>> tls = voiceLeading.ThreeNoteLinearSegment('C3', 'D3', 'E3')
>>> tls.couldBeDiatonicPassingTone()
True

ThreeNoteLinearSegment.couldBeNeighborTone()

checks if noteToAnalyze could be a neighbor tone, either a diatonic neighbor tone or a chromatic neighbor tone. Does NOT check if tone is non-harmonic.

>>> voiceLeading.ThreeNoteLinearSegment('E3', 'F3', 'E3').couldBeNeighborTone()
True
>>> voiceLeading.ThreeNoteLinearSegment('B-4', 'C5', 'B-4').couldBeNeighborTone()
True
>>> voiceLeading.ThreeNoteLinearSegment('B4', 'C5', 'B4').couldBeNeighborTone()
True
>>> voiceLeading.ThreeNoteLinearSegment('G4', 'F#4', 'G4').couldBeNeighborTone()
True
>>> voiceLeading.ThreeNoteLinearSegment('E-3', 'F3', 'E-4').couldBeNeighborTone()
False
>>> voiceLeading.ThreeNoteLinearSegment('C3', 'D3', 'E3').couldBeNeighborTone()
False
>>> voiceLeading.ThreeNoteLinearSegment('A3', 'C3', 'D3').couldBeNeighborTone()
False

ThreeNoteLinearSegment.couldBePassingTone() → bool

checks if the two intervals are steps and if these steps are moving in the same direction. Returns True if the tone is identified as either a chromatic passing tone or a diatonic passing tone. Only major and minor diatonic passing tones are recognized (not pentatonic or scales beyond twelve-notes). Does NOT check if tone is non-harmonic.

Accepts pitch or note objects; method is dependent on octave information

>>> voiceLeading.ThreeNoteLinearSegment('C#4', 'D4', 'E-4').couldBePassingTone()
True
>>> voiceLeading.ThreeNoteLinearSegment('C3', 'D3', 'E3').couldBePassingTone()
True
>>> voiceLeading.ThreeNoteLinearSegment('E-3', 'F3', 'G-3').couldBePassingTone()
True
>>> voiceLeading.ThreeNoteLinearSegment('C3', 'C3', 'C3').couldBePassingTone()
False
>>> voiceLeading.ThreeNoteLinearSegment('A3', 'C3', 'D3').couldBePassingTone()
False

Directionality must be maintained

>>> voiceLeading.ThreeNoteLinearSegment('B##3', 'C4', 'D--4').couldBePassingTone()
False

If no octave is given then ._defaultOctave is used. This is generally octave 4

>>> voiceLeading.ThreeNoteLinearSegment('C', 'D', 'E').couldBePassingTone()
True
>>> voiceLeading.ThreeNoteLinearSegment('C4', 'D', 'E').couldBePassingTone()
True
>>> voiceLeading.ThreeNoteLinearSegment('C5', 'D', 'E').couldBePassingTone()
False

Method returns True if either a chromatic passing tone or a diatonic passing tone is identified. Spelling of the pitch does matter!

>>> voiceLeading.ThreeNoteLinearSegment('B3', 'C4', 'B##3').couldBePassingTone()
False
>>> voiceLeading.ThreeNoteLinearSegment('A##3', 'C4', 'E---4').couldBePassingTone()
False
>>> voiceLeading.ThreeNoteLinearSegment('B3', 'C4', 'D-4').couldBePassingTone()
True
>>> voiceLeading.ThreeNoteLinearSegment('B3', 'C4', 'C#4').couldBePassingTone()
True

Methods inherited from Music21Object:

clearCache() containerHierarchy() contextSites() getAllContextsByClass() getContextByClass() getOffsetBySite() getOffsetInHierarchy()

getSpannerSites() informSites() mergeAttributes() next() previous() purgeLocations() purgeOrphans()

setOffsetBySite() show() sortTuple() splitAtDurations() splitAtQuarterLength() splitByQuarterLengths() write()

Methods inherited from ProtoM21Object:

isClassOrSubclass()

ThreeNoteLinearSegment instance variables

Instance variables inherited from Music21Object:

classSortOrder groups

isStream

sites

Verticality

class music21.voiceLeading.Verticality(contentDict: dict)

DEPRECATED in v7 in favor of tree.verticality.Verticality

A Verticality (previously called “vertical slice”) object provides more accessible information about vertical moments in a score. A Verticality is instantiated by passing in a dictionary of the form {partNumber: [ music21Objects ] }

Verticalities are useful to provide direct and easy access to objects in a part. A list of Verticalities, although similar to the list of chords from a chordified score, provides easier access to part number information and identity of objects in the score. Plus, the objects in a Verticality point directly to the objects in the score, so modifying a Verticality taken from a score is the same as modifying the elements of the Verticality in the score directly.

>>> vs1 = voiceLeading.Verticality({0: [note.Note('A4'), harmony.ChordSymbol('Cm')],
...                                 1: [note.Note('F2')]})
>>> vs1.getObjectsByClass(note.Note)
[<music21.note.Note A>, <music21.note.Note F>]
>>> vs1.getObjectsByPart(0, note.Note)
<music21.note.Note A>

Verticality bases

• Music21Object

• ProtoM21Object

Verticality read-only properties

Verticality.objects

return a list of all the music21 objects in the Verticality

>>> vs1 = voiceLeading.Verticality({0: [harmony.ChordSymbol('C'), note.Note('A4'),],
...                                 1: [note.Note('C')]})
>>> vs1.objects
[<music21.harmony.ChordSymbol C>, <music21.note.Note A>, <music21.note.Note C>]

Read-only properties inherited from Music21Object:

beat beatDuration beatStr

beatStrength hasEditorialInformation

hasStyleInformation measureNumber

Read-only properties inherited from ProtoM21Object:

classSet

classes

Verticality read/write properties

Verticality.color

sets the color of each element in the Verticality

>>> vs1 = voiceLeading.Verticality({1:note.Note('C'), 2:harmony.ChordSymbol('D')})
>>> vs1.color = 'blue'
>>> [(x, x.style.color) for x in vs1.objects]
[(<music21.note.Note C>, 'blue'), (<music21.harmony.ChordSymbol D>, 'blue')]

Verticality.lyric

sets each object on the Verticality to have the passed in lyric

>>> h = voiceLeading.Verticality({1: note.Note('C'), 2: harmony.ChordSymbol('C')})
>>> h.lyric = 'Verticality 1'
>>> h.getStream().flatten().getElementsByClass(note.Note).first().lyric
'Verticality 1'

Read/write properties inherited from Music21Object:

activeSite derivation duration editorial

id offset priority

quarterLength seconds style

Verticality methods

Verticality.changeDurationOfAllObjects(newQuarterLength)

changes the duration of all objects in Verticality

>>> n1 =  note.Note('C4')
>>> n1.quarterLength = 1
>>> n2 =  note.Note('G4')
>>> n2.quarterLength = 2
>>> cs = harmony.ChordSymbol('C')
>>> cs.quarterLength = 4
>>> vs1 = voiceLeading.Verticality({0:n1, 1:n2, 2:cs})
>>> vs1.changeDurationOfAllObjects(1.5)
>>> [x.quarterLength for x in vs1.objects]
[1.5, 1.5, 1.5]

Note: capitalization of function changed in v5.7

Verticality.getChord()

extracts all simultaneously sounding pitches (from chords, notes, harmony objects, etc.) and returns as a chord. Pretty much returns the Verticality to a chordified output.

>>> N = note.Note
>>> vs1 = voiceLeading.Verticality({0:N('A4'), 1:chord.Chord(['B', 'C', 'A']), 2:N('A')})
>>> vs1.getChord()
<music21.chord.Chord A4 B C A A>
>>> voiceLeading.Verticality({0:N('A3'),
...                           1:chord.Chord(['F3', 'D4', 'A4']),
...                           2:harmony.ChordSymbol('Am')}).getChord()
<music21.chord.Chord A3 F3 D4 A4 A2 C3 E3>

Verticality.getLongestDuration()

returns the longest duration that exists among all elements

>>> n1 =  note.Note('C4')
>>> n1.quarterLength = 1
>>> n2 =  note.Note('G4')
>>> n2.quarterLength = 2
>>> cs = harmony.ChordSymbol('C')
>>> cs.quarterLength = 4
>>> vs1 = voiceLeading.Verticality({0:n1, 1:n2, 2:cs})
>>> vs1.getLongestDuration()
4.0

Verticality.getObjectsByClass(classFilterList, partNums=None)

returns a list of all objects in the Verticality of a type contained in the classFilterList. Optionally specify part numbers to only search for matching objects

>>> N = note.Note
>>> vs1 = voiceLeading.Verticality({0: [N('A4'), harmony.ChordSymbol('C')],
...                                 1: [N('C')],
...                                 2: [N('B'), N('F#')]})
>>> vs1.getObjectsByClass('Note')
[<music21.note.Note A>, <music21.note.Note C>,
 <music21.note.Note B>, <music21.note.Note F#>]
>>> vs1.getObjectsByClass('Note', [1, 2])
[<music21.note.Note C>, <music21.note.Note B>, <music21.note.Note F#>]

Verticality.getObjectsByPart(partNum, classFilterList=None)

returns the list of music21 objects associated with a given part number (if more than one). returns the single object if only one. Optionally specify which type of objects to return with classFilterList

>>> vs1 = voiceLeading.Verticality({0: [note.Note('A4'), harmony.ChordSymbol('C')],
...                                 1: [note.Note('C')]})
>>> vs1.getObjectsByPart(0, classFilterList=['Harmony'])
<music21.harmony.ChordSymbol C>
>>> vs1.getObjectsByPart(0)
[<music21.note.Note A>, <music21.harmony.ChordSymbol C>]
>>> vs1.getObjectsByPart(1)
<music21.note.Note C>

Verticality.getShortestDuration()

returns the smallest quarterLength that exists among all elements

>>> n1 =  note.Note('C4')
>>> n1.quarterLength = 1
>>> n2 =  note.Note('G4')
>>> n2.quarterLength = 2
>>> cs = harmony.ChordSymbol('C')
>>> cs.quarterLength = 4
>>> vs1 = voiceLeading.Verticality({0:n1, 1:n2, 2:cs})
>>> vs1.getShortestDuration()
1.0

Verticality.getStream()

returns a stream representation of this Verticality. Correct key, meter, and time signatures will be included if they are found in the context of the first part

>>> vs1 = voiceLeading.Verticality({0: [harmony.ChordSymbol('C'), note.Note('A4'),],
...                                 1: [note.Note('C')]})
>>> vsStream = vs1.getStream()
>>> vsStream.show('text')
{0.0} <music21.stream.Part part-0>
    {0.0} <music21.harmony.ChordSymbol C>
    {0.0} <music21.note.Note A>
{0.0} <music21.stream.Part part-1>
    {0.0} <music21.note.Note C>

How many notes are there anywhere in the hierarchy?

>>> len(vsStream[note.Note])
2
>>> len(vsStream[harmony.Harmony])
1

Verticality.getVerticalityOffset(*, leftAlign=True)

returns the overall offset of the Verticality. Typically, this would just be the offset of each object in the Verticality, and each object would have the same offset. However, if the duration of one object in the slice is different from the duration of another, and that other starts after the first, but the first is still sounding, then the offsets would be different. In this case, specify leftAlign=True to return the lowest valued-offset of all the objects in the Verticality. If you prefer the offset of the right-most starting object, then specify leftAlign=False

>>> s = stream.Score()
>>> n1 = note.Note('A4', quarterLength=1.0)
>>> s.append(n1)
>>> n1.offset
0.0
>>> n2 = note.Note('F2', quarterLength =0.5)
>>> s.append(n2)
>>> n2.offset
1.0
>>> vs = voiceLeading.Verticality({0:n1, 1: n2})
>>> vs.getObjectsByClass(note.Note)
[<music21.note.Note A>, <music21.note.Note F>]

>>> vs.getVerticalityOffset(leftAlign=True)
0.0
>>> vs.getVerticalityOffset(leftAlign=False)
1.0

Changed in v8 – renamed getVerticalityOffset to not conflict with

.offset property. Made leftAlign keyword only

Verticality.isConsonant()

evaluates whether this Verticality moment is consonant or dissonant according to the common-practice consonance rules. Method generates chord of all simultaneously sounding pitches, then calls isConsonant()

>>> V = voiceLeading.Verticality
>>> N = note.Note
>>> V({0: N('A4'), 1: N('B4'), 2: N('A4')}).isConsonant()
False
>>> V({0: N('A4'), 1: N('B4'), 2: N('C#4')}).isConsonant()
False
>>> V({0: N('C3'), 1: N('G5'), 2: chord.Chord(['C3', 'E4', 'G5'])}).isConsonant()
True
>>> V({0: N('A3'), 1: N('B3'), 2: N('C4')}).isConsonant()
False
>>> V({0: N('C1'), 1: N('C2'), 2: N('C3'),
...    3: N('G1'), 4: N('G2'), 5: N('G3')}).isConsonant()
True
>>> V({0: N('A3'), 1: harmony.ChordSymbol('Am')}).isConsonant()
True

Verticality.makeAllLargestDuration()

locates the largest duration of all elements in the Verticality and assigns this duration to each element

>>> n1 =  note.Note('C4')
>>> n1.quarterLength = 1
>>> n2 =  note.Note('G4')
>>> n2.quarterLength = 2
>>> cs = harmony.ChordSymbol('C')
>>> cs.quarterLength = 4
>>> vs1 = voiceLeading.Verticality({0:n1, 1:n2, 2:cs})
>>> vs1.makeAllLargestDuration()
>>> [x.quarterLength for x in vs1.objects]
[4.0, 4.0, 4.0]

Verticality.makeAllSmallestDuration()

locates the smallest duration of all elements in the Verticality and assigns this duration to each element

>>> n1 =  note.Note('C4')
>>> n1.quarterLength = 1
>>> n2 =  note.Note('G4')
>>> n2.quarterLength = 2
>>> cs = harmony.ChordSymbol('C')
>>> cs.quarterLength = 4
>>> vs1 = voiceLeading.Verticality({0:n1, 1:n2, 2:cs})
>>> vs1.makeAllSmallestDuration()
>>> [x.quarterLength for x in vs1.objects]
[1.0, 1.0, 1.0]

Methods inherited from Music21Object:

clearCache() containerHierarchy() contextSites() getAllContextsByClass() getContextByClass() getOffsetBySite() getOffsetInHierarchy()

getSpannerSites() informSites() mergeAttributes() next() previous() purgeLocations() purgeOrphans()

setOffsetBySite() show() sortTuple() splitAtDurations() splitAtQuarterLength() splitByQuarterLengths() write()

Methods inherited from ProtoM21Object:

isClassOrSubclass()

Verticality instance variables

Verticality.contentDict

Dictionary representing contents of Verticalities. the keys of the dictionary are the part numbers and the element at each key is a list of music21 objects (allows for multiple voices in a single part)

Instance variables inherited from Music21Object:

classSortOrder groups

isStream

sites

VerticalityNTuplet

class music21.voiceLeading.VerticalityNTuplet(listOfVerticalities)

a collection of n number of Verticalities. These objects are useful when analyzing counterpoint motion and music theory elements such as passing tones

VerticalityNTuplet bases

• Music21Object

• ProtoM21Object

VerticalityNTuplet read-only properties

Read-only properties inherited from Music21Object:

beat beatDuration beatStr

beatStrength hasEditorialInformation

hasStyleInformation measureNumber

Read-only properties inherited from ProtoM21Object:

classSet

classes

VerticalityNTuplet read/write properties

Read/write properties inherited from Music21Object:

activeSite derivation duration editorial

id offset priority

quarterLength seconds style

VerticalityNTuplet methods

Methods inherited from Music21Object:

clearCache() containerHierarchy() contextSites() getAllContextsByClass() getContextByClass() getOffsetBySite() getOffsetInHierarchy()

getSpannerSites() informSites() mergeAttributes() next() previous() purgeLocations() purgeOrphans()

setOffsetBySite() show() sortTuple() splitAtDurations() splitAtQuarterLength() splitByQuarterLengths() write()

Methods inherited from ProtoM21Object:

isClassOrSubclass()

VerticalityNTuplet instance variables

Instance variables inherited from Music21Object:

classSortOrder groups

isStream

sites

MotionType

class music21.voiceLeading.MotionType(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

NChordLinearSegment

class music21.voiceLeading.NChordLinearSegment(chordList)

NChordLinearSegment bases

• NObjectLinearSegment

• Music21Object

• ProtoM21Object

NChordLinearSegment read-only properties

NChordLinearSegment.chordList

Returns a list of all chord symbols in this linear segment. Modifying the list does not change the linear segment.

>>> n = voiceLeading.NChordLinearSegment([harmony.ChordSymbol('Am'),
...                                       harmony.ChordSymbol('F7'),
...                                       harmony.ChordSymbol('G9')])
>>> n.chordList
[<music21.harmony.ChordSymbol Am>,
 <music21.harmony.ChordSymbol F7>,
 <music21.harmony.ChordSymbol G9>]

Read-only properties inherited from Music21Object:

beat beatDuration beatStr

beatStrength hasEditorialInformation

hasStyleInformation measureNumber

Read-only properties inherited from ProtoM21Object:

classSet

classes

NChordLinearSegment read/write properties

Read/write properties inherited from Music21Object:

activeSite derivation duration editorial

id offset priority

quarterLength seconds style

NChordLinearSegment methods

Methods inherited from Music21Object:

clearCache() containerHierarchy() contextSites() getAllContextsByClass() getContextByClass() getOffsetBySite() getOffsetInHierarchy()

getSpannerSites() informSites() mergeAttributes() next() previous() purgeLocations() purgeOrphans()

setOffsetBySite() show() sortTuple() splitAtDurations() splitAtQuarterLength() splitByQuarterLengths() write()

Methods inherited from ProtoM21Object:

isClassOrSubclass()

NChordLinearSegment instance variables

Instance variables inherited from Music21Object:

classSortOrder groups

isStream

sites

NNoteLinearSegment

class music21.voiceLeading.NNoteLinearSegment(noteList)

a list of n notes strung together in a sequence noteList = [note1, note2, note3, …, note-n ] Once this object is created with a noteList, the noteList may not be changed

>>> n = voiceLeading.NNoteLinearSegment(['A', 'C', 'D'])
>>> n.noteList
[<music21.note.Note A>, <music21.note.Note C>, <music21.note.Note D>]

NNoteLinearSegment bases

• Music21Object

• ProtoM21Object

NNoteLinearSegment read-only properties

NNoteLinearSegment.melodicIntervals

calculates the melodic intervals and returns them as a list, with the interval at 0 being the interval between the first and second note.

>>> linSeg = voiceLeading.NNoteLinearSegment([note.Note('A'), note.Note('B'),
...            note.Note('C'), note.Note('D')])
>>> linSeg.melodicIntervals
[<music21.interval.Interval M2>,
 <music21.interval.Interval M-7>,
 <music21.interval.Interval M2>]

NNoteLinearSegment.noteList

Read-only property – returns a copy of the list of notes in the linear segment.

>>> n = voiceLeading.NNoteLinearSegment(['A', 'B5', 'C', 'F#'])
>>> n.noteList
[<music21.note.Note A>, <music21.note.Note B>,
 <music21.note.Note C>, <music21.note.Note F#>]

Read-only properties inherited from Music21Object:

beat beatDuration beatStr

beatStrength hasEditorialInformation

hasStyleInformation measureNumber

Read-only properties inherited from ProtoM21Object:

classSet

classes

NNoteLinearSegment read/write properties

Read/write properties inherited from Music21Object:

activeSite derivation duration editorial

id offset priority

quarterLength seconds style

NNoteLinearSegment methods

Methods inherited from Music21Object:

clearCache() containerHierarchy() contextSites() getAllContextsByClass() getContextByClass() getOffsetBySite() getOffsetInHierarchy()

getSpannerSites() informSites() mergeAttributes() next() previous() purgeLocations() purgeOrphans()

setOffsetBySite() show() sortTuple() splitAtDurations() splitAtQuarterLength() splitByQuarterLengths() write()

Methods inherited from ProtoM21Object:

isClassOrSubclass()

NNoteLinearSegment instance variables

Instance variables inherited from Music21Object:

classSortOrder groups

isStream

sites

NObjectLinearSegment

class music21.voiceLeading.NObjectLinearSegment(objectList)

NObjectLinearSegment bases

• Music21Object

• ProtoM21Object

NObjectLinearSegment read-only properties

Read-only properties inherited from Music21Object:

beat beatDuration beatStr

beatStrength hasEditorialInformation

hasStyleInformation measureNumber

Read-only properties inherited from ProtoM21Object:

classSet

classes

NObjectLinearSegment read/write properties

Read/write properties inherited from Music21Object:

activeSite derivation duration editorial

id offset priority

quarterLength seconds style

NObjectLinearSegment methods

Methods inherited from Music21Object:

clearCache() containerHierarchy() contextSites() getAllContextsByClass() getContextByClass() getOffsetBySite() getOffsetInHierarchy()

getSpannerSites() informSites() mergeAttributes() next() previous() purgeLocations() purgeOrphans()

setOffsetBySite() show() sortTuple() splitAtDurations() splitAtQuarterLength() splitByQuarterLengths() write()

Methods inherited from ProtoM21Object:

isClassOrSubclass()

NObjectLinearSegment instance variables

Instance variables inherited from Music21Object:

classSortOrder groups

isStream

sites

TwoChordLinearSegment

class music21.voiceLeading.TwoChordLinearSegment(chordList, chord2=None)

TwoChordLinearSegment bases

• NChordLinearSegment

• NObjectLinearSegment

• Music21Object

• ProtoM21Object

TwoChordLinearSegment read-only properties

Read-only properties inherited from NChordLinearSegment:

chordList

Read-only properties inherited from Music21Object:

beat beatDuration beatStr

beatStrength hasEditorialInformation

hasStyleInformation measureNumber

Read-only properties inherited from ProtoM21Object:

classSet

classes

TwoChordLinearSegment read/write properties

Read/write properties inherited from Music21Object:

activeSite derivation duration editorial

id offset priority

quarterLength seconds style

TwoChordLinearSegment methods

TwoChordLinearSegment.bassInterval()

returns the chromatic interval between the basses of the two chord symbols

>>> h = voiceLeading.TwoChordLinearSegment(harmony.ChordSymbol('C/E'),
...                                        harmony.ChordSymbol('G'))
>>> h.bassInterval()
<music21.interval.ChromaticInterval 3>

TwoChordLinearSegment.rootInterval()

returns the chromatic interval between the roots of the two chord symbols

>>> h = voiceLeading.TwoChordLinearSegment([harmony.ChordSymbol('C'),
...                                         harmony.ChordSymbol('G')])
>>> h.rootInterval()
<music21.interval.ChromaticInterval 7>

Methods inherited from Music21Object:

clearCache() containerHierarchy() contextSites() getAllContextsByClass() getContextByClass() getOffsetBySite() getOffsetInHierarchy()

getSpannerSites() informSites() mergeAttributes() next() previous() purgeLocations() purgeOrphans()

setOffsetBySite() show() sortTuple() splitAtDurations() splitAtQuarterLength() splitByQuarterLengths() write()

Methods inherited from ProtoM21Object:

isClassOrSubclass()

TwoChordLinearSegment instance variables

Instance variables inherited from Music21Object:

classSortOrder groups

isStream

sites

VerticalityTriplet

class music21.voiceLeading.VerticalityTriplet(listOfVerticalities)

a collection of three Verticalities

VerticalityTriplet bases

• VerticalityNTuplet

• Music21Object

• ProtoM21Object

VerticalityTriplet read-only properties

Read-only properties inherited from Music21Object:

beat beatDuration beatStr

beatStrength hasEditorialInformation

hasStyleInformation measureNumber

Read-only properties inherited from ProtoM21Object:

classSet

classes

VerticalityTriplet read/write properties

Read/write properties inherited from Music21Object:

activeSite derivation duration editorial

id offset priority

quarterLength seconds style

VerticalityTriplet methods

VerticalityTriplet.hasNeighborTone(partNumToIdentify, unaccentedOnly=False)

return true if this Verticality triplet contains a neighbor tone music21 currently identifies neighbor tones by analyzing both horizontal motion and vertical motion. It first checks to see if the note could be a neighbor tone based on the notes linearly adjacent to it. It then checks to see if the note’s vertical context is dissonant, while the Verticalities to the left and right are consonant

partNum is the part (starting with 0) to identify the passing tone for use on 3 Verticalities (3-tuplet)

>>> vs1 = voiceLeading.Verticality({0:note.Note('E-4'), 1: note.Note('C3')})
>>> vs2 = voiceLeading.Verticality({0:note.Note('E-4'), 1: note.Note('B2')})
>>> vs3 = voiceLeading.Verticality({0:note.Note('C5'), 1: note.Note('C3')})
>>> vt = voiceLeading.VerticalityTriplet([vs1, vs2, vs3])
>>> vt.hasNeighborTone(1)
True

VerticalityTriplet.hasPassingTone(partNumToIdentify, unaccentedOnly=False)

return true if this Verticality triplet contains a passing tone music21 currently identifies passing tones by analyzing both horizontal motion and vertical motion. It first checks to see if the note could be a passing tone based on the notes linearly adjacent to it. It then checks to see if the note’s vertical context is dissonant, while the Verticalities to the left and right are consonant

partNum is the part (starting with 0) to identify the passing tone

>>> vs1 = voiceLeading.Verticality({0:note.Note('A4'), 1:note.Note('F2')})
>>> vs2 = voiceLeading.Verticality({0:note.Note('B-4'), 1:note.Note('F2')})
>>> vs3 = voiceLeading.Verticality({0:note.Note('C5'), 1:note.Note('E2')})
>>> vt = voiceLeading.VerticalityTriplet([vs1, vs2, vs3])
>>> vt.hasPassingTone(0)
True
>>> vt.hasPassingTone(1)
False

Methods inherited from Music21Object:

clearCache() containerHierarchy() contextSites() getAllContextsByClass() getContextByClass() getOffsetBySite() getOffsetInHierarchy()

getSpannerSites() informSites() mergeAttributes() next() previous() purgeLocations() purgeOrphans()

setOffsetBySite() show() sortTuple() splitAtDurations() splitAtQuarterLength() splitByQuarterLengths() write()

Methods inherited from ProtoM21Object:

isClassOrSubclass()

VerticalityTriplet instance variables

Instance variables inherited from Music21Object:

classSortOrder groups

isStream

sites

Functions

music21.voiceLeading.getVerticalityFromObject(music21Obj, scoreObjectIsFrom, classFilterList=None)

returns the Verticality object given a score, and a music21 object within this score (under development)

>>> c = corpus.parse('bach/bwv66.6')
>>> n1 = c.flatten().getElementsByClass(note.Note).first()
>>> voiceLeading.getVerticalityFromObject(n1, c)
<music21.voiceLeading.Verticality
    contentDict={0: [<music21.instrument.Instrument 'P1: Soprano: Instrument 1'>,
                     <music21.clef.TrebleClef>,
                     <music21.key.Key of f# minor>,
                     <music21.meter.TimeSignature 4/4>,
                     <music21.note.Note C#>],
          1: [<music21.instrument.Instrument 'P2: Alto: Instrument 2'>,
              <music21.clef.TrebleClef>,
              <music21.key.Key of f# minor>,
              <music21.meter.TimeSignature 4/4>,
              <music21.note.Note E>],
          2: [<music21.instrument.Instrument 'P3: Tenor: Instrument 3'>,
              <music21.clef.BassClef>,
              <music21.key.Key of f# minor>,
              <music21.meter.TimeSignature 4/4>,
              <music21.note.Note A>],
          3: [<music21.instrument.Instrument 'P4: Bass: Instrument 4'>,
              <music21.clef.BassClef>,
              <music21.key.Key of f# minor>,
              <music21.meter.TimeSignature 4/4>,
              <music21.note.Note A>]}>

for getting things at the beginning of scores, probably better to use a classFilterList:

>>> voiceLeading.getVerticalityFromObject(n1, c,
...                      classFilterList=[note.Note, chord.Chord, note.Rest])
<music21.voiceLeading.Verticality contentDict={0: [<music21.note.Note C#>],
          1: [<music21.note.Note E>],
          2: [<music21.note.Note A>],
          3: [<music21.note.Note A>]}>