Network for String Quartet

I’ve mentioned the piece a couple of times on here over the last few months, but wanted to wait for a performance/recording to explain it a little more. So here we are at last: Network no.1 for string quartet.

The score is a hybrid of graphic and traditional, with a graph network diagram functioning as a map, and traditionally notated reference. Each ‘node’ on the map relates to an element from the separately notated gamut of sonorities. The edges of the map signify a potential route from one musical element to another. The length of an edge determines the duration of the element to be performed. So in this sense the map represents the time-space and structure of the piece, while the reference contains the sonic material.

As previously mentioned, the work exists in a a state of non-linearity. Performers work independently, following their own paths across score ‘maps’. Routes are determined stochastically (and regenerated each time the network graphs are compiles), although each player may choose their own starting point.

The recording was made on Tuesday, 7th May, 2013. Many thanks to the performers for their time:

Violins – Alice Dawkins; Hannah Packman
Viola – Katherine Lambeth
Violoncello – Claudia Chapman

Thanks also to Tony @Big_Pause for his patient advice during the programming stage.

Beeblebrox and the Infinite Improbability Drive {Python}

Trying to deal with an issue in my first string quartet, where performers are faced with a probabilistic decision… being that musicians are not computers, I’m looking at pre-calculating these probabilities, whilst trying to find a way to keep my score system indeterminate (more on that later). Some code I knocked up today to calculate probabilities for weighted edges in a graph network.

### Weighted outcome calculator for Network #1 (String Quartet #1)
# owmtxy, feb 2013 - python, v.2.7
# Input up to 5 probability percentages, and calculate a weighted outcome

import random

elapsed = 0
duration = 0 #int(input("Enter duration: "))

while(elapsed < 840): # While the elapsed time is < 14 minutes
    print("nEnter probabilites, smallest first (0 for unused edges)...")
    # Enter each (accumulative) probability weighting (%)
    val1 = int(input("Weighting A: "))
    val2 = val1 + int(input("Weighting B: "))
    val3 = val2 + int(input("Weighting C: "))
    val4 = val3 + int(input("Weighting D: "))
    val5 = val4 + int(input("Weighting E: "))

    def makeRandom():
        randomVal = random.random() # Generate a random 'deciding' value
        randomVal = round(randomVal*100) #Scale it to a %
        return(int(randomVal))

    randomX = makeRandom()
    print(randomX)

# Compare the randomX value to the probability boundries:
    if(randomX <= val1): print("Outcome A") elif (randomX > val1) and (randomX <= val2): print("Outcome B") elif (randomX > val2) and (randomX <= val3): print("Outcome C") elif (randomX > val3) and (randomX <= val4): print("Outcome D") elif (randomX > val4) and (randomX <= val5): print("Outcome E") # Add the duration of the selected edge to the elapsed time duration = int(input("Enter duration: ")) elapsed += duration print("Elapsed time: ", elapsed/60) # Repeat until we reach > 14 minutes

[VIDEO] from Hibernate’s “Winter’s Gift”, live at Cafe Oto

Happy Holidays! Gianmarco Del Re has made a rather wonderful video of Hibernate’s christmas bash we played at on Dec 15th, 2012. It’s got some really nice shots of the gear we used that night and James and I trying to keep it under control.

Hibernate A Winter’s Gift from Gianmarco Del Re on Vimeo.

The sound seems only to be from our intro though so doesn’t totally capture the sound of the set, but a very good watch.

Shortly after this set I was also very kindly asked to come on Rich Hughes’ Cambridge radio show ‘The Visitor‘ for a chat and a bit of a live set. Unfortunately my gear crashed in the first take so had to try and pull it back with some chatter and spectralist improv. Now, you too can listen to me die of embarrassment on-air and talk about Aaliyah!

First test of the Hailstone Piano

I’m currently working on a composition which uses the Collatz Conjecture (or Hailstone Numbers) as source data in a piece for solo Disklavier Piano. Below is a screenshot from a (currently too messy to post) Processing script I wrote to get a better idea of the behavior of these numbers.

The first run is essentially just about getting the Javascript to calculate the numbers, and Max/MSP to spit them out to the Piano. Still looking for an effective way to map the numbers into notes, but for now just getting all the tech to play nice and a feel for the instrument’s behaviour.

Collatz Piano (test#1) from Ithaca Trio on Vimeo.

The main inspiration behind the piece is György Ligeti’s Piano Etude no.1: Disordre. I love the frenetic pace, and the algorithmically derived recursion of the piece, but with the Collatz project I’m toying with the concept of softening the aggressive/human element of that speed (the Disklavier can play very fast with a ‘softer’ touch/velocity), in a falling ‘hailstone’ pattern.