## Archive for November, 2010

### Real voices, electronic voices or electronic sounds?

Wednesday, November 10th, 2010

In the last days I make thoughts about the instrumentation of this piece.

• If I write it for choir, then
• either I should notate it exactly and supply electronic recordings for each part, so that the choir can study the non standard tuning. In this case, the rehearsal would be a difficult and expensive task, that is the work would get performed very rarely.
• or I should adjust the non standard tuning to microtonal tuning of ¼ of a tone. Then it could be performed more frequently, but in this case not precisely.
• If I write the piece for electronic voices, then I have precision, a choir, but a cheap imitation of the human voice.
• If I write the piece for electronics, then I have to work hard in order to achieve a nice timbre. And nobody pays me for this… I.e. it could take months or years.

What should I do? I still don’t know.

### Comment: The Model

Tuesday, November 9th, 2010

Which is the model behind this construction? Now, after Phase 2, it has become clear to me: before several years, while studying musicology, I had seen a mensuration canon of a Renaissance composer. IIRC It began with g’, was for 3 voices and the analogies were 1:2:3. If someone could tell me which piece it is, I would be grateful.

### Phase 2: Create the data

Tuesday, November 9th, 2010

In order to stretch equidistant the Fibonacci sequences modulo m (m=2,…,12) to fit the same space, I just modified the previous Python script:

```def my_zeros(n):
result = []
for i in range(n):
result.append(0)
return result

# print the numbers for the respective
# subdividion of the octave
def divide_oct(modulo):
f = open('mod_'+str(modulo)+'.data', 'w')
max = modulo**2
fibonacci = my_zeros(max)
fibonacci = 0
fibonacci = 1
j = 2
for j in range(2, max):
fibonacci[j] = (fibonacci[j-1] + fibonacci[j-2]) % modulo
# the 2 last numbers x=F_(n-1) y=F_n of the period
# must satisfy the following (for modulo m):
# x + y = 0 mod m
# y + 0 = 1 mod m
# because 0 and 1 should be the next numbers.
# Thus (x,y) = (m-1, 1).
if fibonacci[j] == 1:
if fibonacci[j-1] == modulo - 1:
per = j + 1
break
for i in range(per):
#print float(i)/per, "\t", fibonacci[i]*1200/modulo
f.write(str(float(i)/per)+"\t"+str(fibonacci[i]*1200/modulo)+'\n')
f.close()

for i in range(2, 13):
divide_oct(i)```

The output is 11 data files: mod_2.data,…, mod_12.data (here are all). Then I wrote a gnuplot script, in order to visualise the results:

```set terminal png
set grid
set yrange [0:1700]
set ytics ('c' 0, 'c#' 100, 'd' 200, 'd#' 300, 'e' 400, 'f' 500, \
'f#' 600, 'g' 700, 'g#' 800, 'a' 900, 'ais' 1000, 'b' 1100, \
'c' 1200);
set xlabel 'Duration'
set ylabel 'Pitch for c := 0'

set output "periods.png"

plot    'mod_2.data' u 1:2 w lp t 'mod  2', \
'mod_3.data' u 1:2 w lp t 'mod  3', \
'mod_4.data' u 1:2 w lp t 'mod  4', \
'mod_5.data' u 1:2 w lp t 'mod  5', \
'mod_6.data' u 1:2 w lp t 'mod  6', \
'mod_7.data' u 1:2 w lp t 'mod  7', \
'mod_8.data' u 1:2 w lp t 'mod  8', \
'mod_9.data' u 1:2 w lp t 'mod  9', \
'mod_10.data' u 1:2 w lp t 'mod 10', \
'mod_11.data' u 1:2 w lp t 'mod 11', \
'mod_12.data' u 1:2 w lp t 'mod 12'```

And the output is: We see here some very interesting properties, which I will not analyse, because of lack of time. I just note, that it is not necessary, that all voices start at the same pitch, but I will adopt this idea, because it reminds me the beginning of some choir works of Josquin. But maybe I will change it later (however with small probability…).

As this graph contains rhythmical and pitch information, I would like to visualize only the rhythmical aspect, in order to have an overview of the resulting rhythmical grid. The new gnuplot script is:

```set terminal png
set grid
set yrange [1:13]
set xlabel 'Duration'
set ylabel 'Modulo'

flat(a,x)=a

set output "periods_flat.png"

plot    'mod_2.data' u 1:(flat(2, \$2)) w lp t '', \
'mod_3.data' u 1:(flat(3, \$2)) w lp t '', \
'mod_4.data' u 1:(flat(4, \$2)) w lp t '', \
'mod_5.data' u 1:(flat(5, \$2)) w lp t '', \
'mod_6.data' u 1:(flat(6, \$2)) w lp t '', \
'mod_7.data' u 1:(flat(7, \$2)) w lp t '', \
'mod_8.data' u 1:(flat(8, \$2)) w lp t '', \
'mod_9.data' u 1:(flat(9, \$2)) w lp t '', \
'mod_10.data' u 1:(flat(10, \$2)) w lp t '', \
'mod_11.data' u 1:(flat(11, \$2)) w lp t '', \
'mod_12.data' u 1:(flat(12, \$2)) w lp t ''
```

and the result: Now, the next step is: select 5 voices out of the grid.

### Phase 1: Fibonacci Sequence modulo m

Tuesday, November 9th, 2010

Before applying the 24:17:13:7:3 sequence of the previous post, I though, that I could check all Fibonacci sequences modulo 2 to 12 (period(12)=24) and see if some are interesting for my goal.

The period of a Fibonacci sequence is called Pisano period and —to my knowledge— there is not a formula with ()+-*/^ that could give them as a function of the modulo m. Thus I wrote a small Python script that does this:

```def my_zeros(n):
result = []
for i in range(n):
result.append(0)
return result

for modulo in range(2,13):
print "modulo =",modulo
max = modulo**2
fibonacci = my_zeros(max)
fibonacci = 0
fibonacci = 1
j = 2
for j in range(2, max):
fibonacci[j] = (fibonacci[j-1] + fibonacci[j-2]) % modulo
# the 2 last numbers x=F_(n-1) y=F_n of the period
# must satisfy the following (for modulo m):
# x + y = 0 mod m
# y + 0 = 1 mod m
# because 0 and 1 should be the next numbers.
# Thus (x,y) = (m-1, 1).
if fibonacci[j] == 1:
if fibonacci[j-1] == modulo - 1:
per = j + 1
break
print fibonacci[0:per]
print "period =", per
print
```

The output is very interesting:

```modulo = 2
[0, 1, 1]
period = 3

modulo = 3
[0, 1, 1, 2, 0, 2, 2, 1]
period = 8

modulo = 4
[0, 1, 1, 2, 3, 1]
period = 6

modulo = 5
[0, 1, 1, 2, 3, 0, 3, 3, 1, 4, 0, 4, 4, 3, 2, 0, 2, 2, 4, 1]
period = 20

modulo = 6
[0, 1, 1, 2, 3, 5, 2, 1, 3, 4, 1, 5, 0, 5, 5, 4, 3, 1, 4, 5, 3, 2, 5, 1]
period = 24

modulo = 7
[0, 1, 1, 2, 3, 5, 1, 6, 0, 6, 6, 5, 4, 2, 6, 1]
period = 16

modulo = 8
[0, 1, 1, 2, 3, 5, 0, 5, 5, 2, 7, 1]
period = 12

modulo = 9
[0, 1, 1, 2, 3, 5, 8, 4, 3, 7, 1, 8, 0, 8, 8, 7, 6, 4, 1, 5, 6, 2, 8, 1]
period = 24

modulo = 10
[0, 1, 1, 2, 3, 5, 8, 3, 1, 4, 5, 9, 4, 3, 7, 0, 7, 7, 4, 1, 5, 6, 1, 7, 8, 5,
3, 8, 1, 9, 0, 9, 9, 8, 7, 5, 2, 7, 9, 6, 5, 1, 6, 7, 3, 0, 3, 3, 6, 9, 5, 4,
9, 3, 2, 5, 7, 2, 9, 1]
period = 60

modulo = 11
[0, 1, 1, 2, 3, 5, 8, 2, 10, 1]
period = 10

modulo = 12
[0, 1, 1, 2, 3, 5, 8, 1, 9, 10, 7, 5, 0, 5, 5, 10, 3, 1, 4, 5, 9, 2, 11, 1]
period = 24

```

Now the idea is the following: let all sequences represent divisions of the octave by the respective modulo (e.g. m=12: semitones, m=11: 1/11 of the octave etc) and stretch them equidistant in order to fill the same duration. Then select the ones that are going to sound at the given position (filtering). Allow rhythmical and pitch deviations. The whole piece is in forte.

About the words: I decided not to use a poem. I think 2 arts at the same time is a bit too much for my taste. Music alone should suffice.

### Piece for choir

Sunday, November 7th, 2010

After writing some stuff on Small Thoughts about the Fibonacci numbers, I decided to write a piece for choir based on this series.

Here I will write my plans and daily remarks about my thoughts on the piece.

Goals:

• A small piece for choir, 2 Alto, Tenor, Baritone, Bass. Low register.
• It should be ready by the end of November.
• The lyrics will be a poem of mine (which one? a new one?).
• The piece should have a rather dark colour.
• It should last about 5 min.
• The higher the voice, the smaller duration values it will use.
• Each voice will make use of a different octave and rhythmic division.

About the last postulate: let the highest voice have a potential of 24 values. Then consider the following division:

VoiceA1A2TBaB
Primary Division24181284
Deviated Division24171373

The octave division will be analogous (:24, :17, :13 etc).

Each voice will posses a predefined grid of tones and time positions according to its division (like the prior filter technique, but much more flexible).