# SimpleBlog

Index of all articles

## How it came to the scores (hummingbird mind thinking and one day of fun)

I’ve read Martin Gardener’s ’’The Colossal Book of Mathematics’’. In chapter 27 ’’Fractal Music’’ he discusses 1/f (pink noise) music generartion. So I was allways interested in algorithmic music and decided to try it with pink noise. Gardener describes Voss’s dice algorithm. It sounded easy, so a straight forward implementation in Ruby (which is the language of choice doing rapid prototyping) was even easier:

### The Pink Noise Generator

```#!/bin/ruby
# save this as "pinknoise.rb"

# helpers:
# Voss uses binary representations of numbers to decide,
# which dice has to be to diced. Here is the function that checks the represtentations:

def getpdif(a,b)
r=Array.new
a.size.times do |i|
r << i if a[i]!=b[i]
end
r
end

# classes:
# Dice Class, but every number of sides is possible:
class Dice
def initialize(sides=6)
@sides=sides
@shows=rand(@sides)
end
def die
@shows=rand(@sides)
end
def shows
@shows
end
end

# Pink Noise Class that computes first what dices
# (number of sides) will be needed, to generate pink noise in the range of r:
class PinkNoise
def initialize(r=12)
@sides=(Math.sqrt(r).to_i)+1
@size=(Math.sqrt(r).to_i)+1
@p0=2**@size
@start=(@p0-1)
@dices=Hash.new
@size.times do |i|
@dices[i+1]=Dice.new(@sides)
end
end
def to_s
[@size,@start,@dices]
end
r=0
@dices.values.each do |y|
r+=y.shows
end
r
end
def next
n=@start+1
n=(n%(2**@size)+@p0)
r=getpdif(n.to_s(2),@start.to_s(2))
@start=n
r.each do |i|
@dices[i].die
end
end
end

# Example:
# pinknoisegenerator = PinkNoise.new(20)
# 10.times do
#   nextevent = pinknoisegenerator.next
# end
```

Fine this works!

If you want to do this and all that follows I reconmend:

1. Use Linux, cause every thing is available (Ruby, Lilypond etc.) and this is an example of thinking unix.
2. Or if you have a MS Laptop like me, use Cygwin where also every thing, you’ll need is available in a unix like enviroment.

### Generating Music and Score (first try)

So what is the easiest way to generate score and midi?

Lilypond

I added this piece of code to pinknoise.rb (remember this is really rapid prototyping):

```# header and footer of a lilypond source file:
\$H=<<EOH
\\version "2.10.33"
\\score {

EOH
\$F=<<EOF

\\layout { }
\\midi { }
}
EOF

class Lily
def initialize(n,tones)
@n=n
@tones=tones
@m=@tones.size
@png=PinkNoise.new(@m)
end
def write
erg=\$H+"{\n"
@n.times do |i|
erg << "\n" if (i+1)%16==0
erg << @tones[@png.next % @m] << "16 "
end
erg << "\n}" << \$F
erg
end
end

c_dur_pent=["c'","e'","f'","g'","a'","c''","e''","f''","g''","a''"]
c_dur=["c'","d'","e'","f'","g'","a'","b'","c''","d''","e''","f''","g''","a''","b''"]
l=Lily.new(64,c_dur)
print l.write

```
Now you do:
1. ruby pinknoise.rb >test.ly
2. lilypond test.ly

and you get ’’test.mid’’ and ’’test.pdf’’, so you can look at the score and hear the midi file.

### The Hummingbird Situation

Until now everything was fine and quite easy. So I began to think about musical form, rythmn, harmonies and so on. Quite complex things. And I really got in panic about all this work with the moods and scales. (Ok, this is not the hard thing in algorithmic music, but it’s still a lot of typing) I thought, there must be someone, who has done all this work and there should be a repository of scales in a common format. So I googeled. And yapadapadoo I found lucytune where Charles Lucy (By the way: Sorry Charles, that until now I have not read all the other material on the luzytune side, but I’m really a hummingbird mind, but I’m sure it’s worth reading) has done a great thing, that caught me at once, cause of his mathematical approach (every possible scale in enharmonic space from unison to twelfetone with base tone c) and on the other side cause he did such a lot of work in finding the namings of the scales.

I downloaded his Excelfile of all Scales base tone c and wow there are so many that make sense.

### Visualisation

Hey Mr. Hummingbird, you wanted to make pink noise music? Ok, this could be done later. Let’s first see what we have got here. There are so many Ragas and I love classical indian music. So let’s visualize first the scales.

Again this could be done with lilypond. But first we need a parser for the xls file.

So let’s save it as csv first. (I used OpenOffice to do this) We now have a 2339.csv file.

Here the ruby programm that reads the csv and makes the lilypond sourcefiles for generating the scores:

```#!/bin/ruby

# the schema of the csv:
\$Pattern=["Name Of Scale", "ScaleCoding", "Pitch Set binary",
"Binary 12notes 1&0", "PitchSet Notation 12 edo", "Note Names from C",
"NotesInStepsOfFifiths", "L and s Interval Sequence", "Major Triads",
"Ascending Note Positions in Scale", "LengthOfChain", "Flatmost Note",
"Sharpmost Note", "Contiguous Notes", "PositionOfTonic"]

# should be called makedutch!
def makeenglish(s)
s=s.gsub("#","is")
s=s.gsub("b","es")
s=s.gsub("Ces","Ces'")
l=s.split(" ").map { |x| x+"'" }
s=l.join(" ")
s.downcase
end

# The parser class (not much parsing more mapping)
class AbstractScale
def initialize(s)
@a=s.chop.split(";")
@attr=Hash.new
@a.each_with_index do |e,i|
@attr[\$Pattern[i]]=e
end
end
def show
p @attr
end
def nameandtones
[makeenglish(@attr["Note Names from C"]),@attr["Name Of Scale"]]
end
def tonesnames
[@attr["Name Of Scale"], makeenglish(@attr["Note Names from C"])]
end
def allattrwithname
erg=[]
\$Pattern.each do |k|
erg << k
erg << @attr[k]
end
erg
end
def astxt
muster="|%s:|%s|\n"
ergh=""
erg=""
li=0
\$Pattern.each do |k|
if li==0
ergh << "h3. %s\n\n" % @attr[k]
else
erg << muster % [k, @attr[k]]
end
li+=1
end
[ergh,erg]
end
def tnumber
@attr["Number Of Notes In Scale"].to_i
end
def nameofscale
@attr["Name Of Scale"]
end
def notenamesbasec
@attr["Note Names from C"]
end

end

# a little helper to make filenames that sort right:
def mn(n)
s=n.to_s
while s.size<4
s="0"+s
end
s
end

# Reading the scales into the list erg.
# 2339-gut because, I had to remove some unicodes to be able to process with lilypond.
erg=[]
open("2339-gut.csv") do |f|
l=l.delete('"')
erg << AbstractScale.new(l)
end
end

# removing the header of the table
erg.delete_at(0)

# test functions: It reads all 2338 scales.
def donan(erg)
erg.each do |as|
p as.nameandtones
end
end

#erg[0].show

#print erg[100].astxt[0]

#donan(erg)

# The lilypond sorcefile template:
\$Score=<<EOSS
\\version "2.10.33"

\\markup { \"%s:\" }

\\score {
\\new GregorianTranscriptionStaff {
%s
}
}

EOSS

# This is the processing. You'll need a pngs dir
li=0
erg.each do |as|
open("pngs/scale%s.ly" % mn(li),"w") do |f|
f.write(\$Score % as.tonesnames)
end
li+=1
end

```

After running this we will have 2338 ’’.ly’’ files named scale0000.ly up to scale2337.ly in the pngs directory.

So now:
1. cd pngs
2. lilypond -dbackend=eps -dno-gs-load-fonts -dinclude-eps-fonts—png *.ly (we want png files not pdf)

and you’ll get 2338 png files, one for every scale. So they will be a4 format, cause my version of lilypond can not produce smaller pngs, but I think version 2.12 can do it. But this version is not available on Cygwin yet.

But this is not a problem, cause we can convert the pngs with the convert tool of ImageMagick which is also available on Linux and Cygwin:

```#!/bin/ruby
# save this as convert.rb
# to become sortable filenames:
def mn(n)
s=n.to_s
while s.size<4
s="0"+s
end
s
end

# I decided to make the small pngs 415x165:
li=0
Dir["pngs/scale*.png"].each do |path|
p path
np="pngs4/s%s.jpg" % mn (li)
`convert #{path} -crop 415x165+210+65 #{np}`
li+=1
end
```

In the pngs dir call ’’ruby convert.rb’’ and you will get s0000.png upto s2337.png which are the small versions of the score pics, which you can download here http://www.muzuu.org/new_life/pics/simpleblog/scales/scalespngs.zip (10 MB)

### Just for fun: A movie with all the scales

This was made with Mencoder of the Mplayer suite.

Ah, I wanted to make pink noise music …