Speed, Speed, Speed, ... and news.

The newest GitHub repository contains a huge change to the under-the-hood processing of .getContextByClass() which is used in about a million places in music21.  It is the function that lets any note know what its current TimeSignature (and thus beatStrength, etc.) is, lets us figure out whether the sharp on a given note should be displayed or not given the current KeySignature, etc.  While we had tried to optimize the hell out of it, it’s been a major bottleneck in music21 for working with very large scores. We sped up parsing (at least the second time through) a lot the last commit. This was the time to speed up Context searching.  We now use a form of AVL tree implemented in a new Stream.timespans module — it’s not well-documented yet, so we’re only exposing it directly in one place, stream.asTimespans(recurse=True|False).  You don’t need to know about this unless you’re a developer; but I wanted to let you know that the results are extraordinary.

Here’s a code snippet that loads a score with three parts and 126 measures and many TimeSignatures and calculates the TimeSignature active for every note, clef, etc. and then prints the time it takes to run:

>>> c = corpus.parse('luca/gloria')

>>> def allContext(c):

...     for n in c.recurse():

...         k = n.getContextByClass('TimeSignature')

... 

>>> from time import time as t

>>> x = t(); allContext(c); print t() - x

with the 1.8 release of Music21:

42.9 seconds

with the newest version in GitHub:

0.70 seconds

There’s a lot of caching that happens along the way, so the second call is much faster:

second call with 1.8 release:

44.6 seconds ( = same within a margin of error)

with the newest version in GitHub if the score hasn’t changed:

0.18 seconds

You’ll see the speedup immensely in places where every combination of notes, etc. needs to be found.  For instance, finding all parallel fifths in a large score of 8 parts could have taken hours before. Now you’ll likely get results in under a few seconds.

I have not heard of any issues arising from the change in sorting from the last posting on April 26, so people who were afraid of updating can breath a bit more easily and update to the version of music21 at least as of yesterday. The newer version, like all GitHub commits, should be used with caution until we make a release.

Thanks to the NEH and the Digging into Data Challenge for supporting the creation of tools for working with much bigger scores than before.

In other news: 

Music21j — a Javascript implementation of music21’s core features — is running rapidly towards a public release.  See http://prolatio.blogspot.com/2014/05/web-pages-with-musical-examples.html for an example of usage.  We’ll be integrating it with the Python version over the summer.

Ian Quinn’s review of Music21 appeared in the Journal of the American Musicological society yesterday.  Prior to this issue, no non-book had ever been reviewed. It’s a great feeling to have people not on this list know about the software as well.

Oh, and MIT was foolhardy enough to give me tenure! Largely on the basis of music21.  If you’re an academic working on a large digital project, I still advice proceeding with caution, but know that it can be done.  Thanks everyone for support.

Plotting pitches and durations continuously in music21

With music21, it's not hard to plot discrete data (pitches, durations, etc.) as continuous data. There isn't a built in tool for doing this, but since music21 is written in Python, it is easy to take advantage of the tools from matplotlib, numpy, and scipy to create "cubic bezier-curve splines" that show these points in an easily visualized format.

In music21 you can easily plot the position of notes as a piano roll:

from music21 import corpus

bach = corpus.parse('bwv66.6')

bach.plot('pianoroll')

which preserves pitch names, measure numbers, etc.  But the case we're asking for requires a plot more like this:

The numbers at the left are midi numbers while the bottom is number of quarter notes from the beginning. Here's some code to help you achieve this:

import numpy as np

import matplotlib.pyplot as plt

from scipy import interpolate

from music21 import corpus

bach = corpus.parse('bwv66.6')

fig = plt.figure()

for i in range(len(bach.parts)):

    top = bach.parts[i].flat.notes

    y = [n.ps for n in top]

    x = [n.offset + n.quarterLength/2.0 for n in top]

    tck = interpolate.splrep(x,y,s=0)

    xnew = np.arange(0,max(x),0.01)

    ynew = interpolate.splev(xnew,tck,der=0)

    

    subplot = fig.add_subplot(111) # semi-arbitrary three-digit number

    subplot.plot(xnew,ynew)

plt.title('Bach motion')

plt.show()

With this sort of graph it's easy to isolate each voice (not much overlap of voices in this chorale) and to see the preponderance of similar motion among the Soprano, Alto, and Tenor, but lack of coordination with the Bass (which would create forbidden parallels if it coordinated).  More sophisticated examples with better labels are easily created by those with knowledge of matplotlib, but this simple demonstration will suffice to get things started.

Music21 on GitHub

Just a quick note that music21's code is now hosted on GitHub at https://github.com/cuthbertLab/music21 .  For people who have been using SVN, we will have instructions on how to make a Fork of the music21 Git repository and to begin contributing pull requests soon.  Please hang tight.

Music21 v.1.7 Released

The newest version of music21, v. 1.7 has been released and is available for download at https://code.google.com/p/music21/downloads/list.

In the three months since v. 1.6 some good changes and improvements have been introduced.  We focused primarily on stabilizing features that were already in music21 in some form but were too experimental to advertise widely.

A noCorpus version of music21 has also been released, the first since v.1.0.  This version can be used in pure Free/Libre projects since files that were licensed for music21 only or non-commercial use have been removed.  If you are not sure which version to download, definitely get the full version. But maintainers of Debian Linux and others can update to 1.7 noCorpus.

Music21 v 1.7 (actually 1.7.1) will be the last version to support Python 2.6. Python 2.7 is over three years old and is supported by other flavors of Python including Jython (which skipped 2.6), PyPy, IronPython and is an easy upgrade for Python on Windows.  Mac users have had 2.7 since Mountain Lion and we're happy to report that with Mavericks being free and supporting systems that can run Snow Leopard, we're happy to be able to use this opportunity to take advantage of the latest features and start a roadmap to supporting Python 3.3 as well.  This is also the last release to use SVN.  We are moving to GitHub.  Updates soon.

The most important improvement for users is a much improved system of metadata searching (thanks to Josiah Oberholtzer). See:

http://web.mit.edu/music21/doc/usersGuide/usersGuide_11_corpusSearching.html

for more details.  LocalCorpus objects are elevated to equal status as the Core corpus so you can now build searchable indexes on any data you have and find the file you want much faster.  Try corpus.search('haydn') and read the docs above to see what's possible.

Among the other 150+ changes since 1.6 include:

• Chord.inversion(2) will take a root position chord and put it in second inversion. (this is a change of behavior from before, where .inversion(2) would specify that the chord was in second inversion and override default inversion reporting (for things like Jazz 6 chords). To get the old behavior, use .inversion(2, transposeOnSet=False)
• Fixes for abc parsing (N.B. the next version will rename the "abc" module to "abcNotation" to avoid the occasional name clash with the python AbstractBaseClass (abc) module).
• Stream.getElementsByOffset(4.0) can now find a zero-length object at 4.0 -- bug fix.
• Many modules are now packages (Stream, for instance).  This should not affect your code.  Existing packages with X/base.py can now find their files in X/__init__.py.  Again, this should not affect your code.
• Page break support in Lilypond.
• MIDI translate works better with instruments (thanks to Christopher Antilla)
• Improvements to Braille Music Code output (thanks to Mario Lang; more to come)
• Bug fixes in measure copying involving pivot chords and secondary dominants in RomanText
• Roman numerals for VII, VI, viio/vii, vi/vio in minor are made more robust.  It6, Ger65, Fr43, are now supported.
• Many many many bug fixes.  Thanks to community help!

Thanks as always to the NEH, Digging into Data program, the Seaver Institute, and MIT for their support of the project.

music21 v.1.6.0 Released

Version 1.6.0 of music21 was released today.  This is the first new release in three months and is available at: http://code.google.com/p/music21/downloads/  .  The release also inaugurates a new documentation system, http://web.mit.edu/music21/doc/ designed by new music21 Lead Programmer, Josiah Wolf Oberholtzer and featuring an expanded User's Guide using the iPython Notebook, which allows for more examples, more graphics, and quicker development.  Expect to see more there soon.

Improved and updated docs were the main focuses of the new release, but you will also find:

• Many improvements and fixes to the harmony.Harmony object.
• Freezing/Thawing of Streams that were originally MIDI files now works.
• Better handling of repeat endings.
• Measure suffixes are handled more "musically"
• Easier setup on UNIX systems and using PIP and other tools.
• Improvements in Lilypond output
• Documentation on using music21 with iPython in a multi-core, cluster environment.

This version of music21 is a larger download than before (68MB as opposed to 30MB) because all of the documentation in both old and new formats is included.  The next version will return to normal size.

One backwards incompatible change: Stream.elements now returns a tuple instead of a List.  This is done to emphasize that .elements should not be changed.  Instead use Stream.append, .remove, .insert, or subscript the Stream object.  Chord.pitches also returns a tuple instead of a List as well.  

Thanks to everyone for their contributions and comments that make music21 work well!