Some Sonic Pi Jewels

Creations & Ideas
1

I would just like to promote a page of Sonic Pi ideas written by Professor Dr. Hiroshi Tachibana @H_Tachibana on this site. He is a long time promoter of Sonic Pi in Japan, and has a web page here.

The page is in Japanese, but the code can be copied directly from it. You can read comments and descriptions by feeding the page through google translate

using this url, however the code is mucked up with extra spaces and can’t be copied directly from the translated page.

To whet your appetite here are a couple snippets from the page.
First a nice recursive program

use_bpm 130
use_debug false
define :tarai do |x,y,z|
  a=[:D4,:E4,:F4,:G4,:A4,:B4,:C5,:D5,:E5,:F5,:G5,:A5,:B5]
  2.times do
    puts x,y,z
    play_pattern_timed [a[x+1],a[x+1]+12,a[y+1],a[y+1]+12,a[z+1],a[z+1]+12,a[y+1],a[y+1]+12],0.25
  end
  n=n+1
  if(x<=y)
    return y
  else
    return tarai( tarai(x-1,y,z), tarai(y-1,z,x), tarai(z-1,x,y))
  end
end

tarai 10,5,0

secondly traversing the circle of fifths at random

# Random walk around on the Circle of Fifth
use_debug false
use_random_seed Time.new.usec
use_synth :pluck
i=0
loop do
  2.times do
    play_pattern_timed (chord 48 + i%12, :major),0.01
    puts i/7, note_info(48 + i%12)
    sleep 0.5
  end
  i=i+(rrand_i(0,2)-1)*7
end

A wide range of topics are covered on the page, including some nice sonification examples. Worth a look.

9 Likes
2

Thanks Robin for introducing my site.

4 Likes
3

Hi there,

I worked on the Perlin Noise Music from Tachibana-san because of the copy-paste-problem as I was interested in how it sounds.
I hope, I didn’t do any mistakes, here is the code to easily copy:

def fastfloor(x)
  (x>0 ? x: x-1).to_i
end

def noise(x, y, z)
  # find unit cube that contains point
  x_ = fastfloor(x) & 255
  y_ = fastfloor(y) & 255
  z_ = fastfloor(z) & 255
  
  # find relative x, y, z of point in cube
  x-= fastfloor(x)
  y-= fastfloor(y)
  z-= fastfloor(z)
  
  # compute fade curves for each of x, y, z
  u = fade(x)
  v = fade(y)
  w = fade(z)
  
  # hash coordinates of the 8 cube corners
  a = PT[x_] + y_
  aa = PT[a] + z_
  ab = PT[a + 1] + z_
  b = PT[x_ + 1] + y_
  ba = PT[b] + z_
  bb = PT[b + 1] + z_
  
  # and add blended results from 8 corners of cube
  lerp(w, lerp(v, lerp(u, grad(PT[aa], x, y, z), grad(PT[ba], x-1, y, z)), lerp(u, grad(PT[ab], x, y-1, z), grad(PT[bb], x-1, y-1, z))), lerp(v, lerp(u, grad(PT[aa + 1], x, y, z-1), grad(PT[ba + 1], x-1, y, z-1)), lerp(u, grad(PT[ab + 1], x, y-1, z-1), grad(PT[bb + 1], x-1, y-1, z-1))));
end

def fade(t); t * t * t * (t * (t * 6-15) + 10); end
def lerp(t, a, b); a + t * (b-a); end
def grad(_hash, x, y, z)
  h = _hash & 15
  u = h<8 ? x: y
  v = h<4 ? y: ((h == 12 || h == 14) ? x: y)
  ((h & 1) == 0 ? u: -u) + ((h & 2) == 0 ? v: -v)
end

PT_PERM = [151,160,137,91,90,15,
           131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,8,99,37,240,21,10,23,
           190, 6,148,247,120,234,75,0,26,197,62,94,252,219,203,117,35,11,32,57,177,33,
           88,237,149,56,87,174,20,125,136,171,168, 68,175,74,165,71,134,139,48,27,166,
           77,146,158,231,83,111,229,122,60,211,133,230,220,105,92,41,55,46,245,40,244,
           102,143,54, 65,25,63,161, 1,216,80,73,209,76,132,187,208, 89,18,169,200,196,
           135,130,116,188,159,86,164,100,109,198,173,186, 3,64,52,217,226,250,124,123,
           5,202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,189,28,42,
           223,183,170,213,119,248,152, 2,44,154,163, 70,221,153,101,155,167, 43,172,9,
           129,22,39,253, 19,98,108,110,79,113,224,232,178,185, 112,104,218,246,97,228,
           251,34,242,193,238,210,144,12,191,179,162,241,81,51,145,235,249,14,239,107,
           49,192,214, 31,181,199,106,157,184, 84,204,176,115,121,50,45,127, 4,150,254,
           138,236,205,93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180]
PT = []; (0 ... 256).each {| i | PT[256 + i] = PT_PERM[i]; PT[i] = PT_PERM[i]}

# The above is the definition part of Perlin Noise function.
# The following is the performance part. After giving the parameters to the function, we get the random value and play.

use_random_seed Time.new.usec # <<<<<
use_synth :piano
x = rand # <<<<<
inc = 0.015 * 3 # <<<<<
loop do
  a = (noise x + inc, x, 0.0) * 20 # <<<<<
  
  a = -60 if a <-60
  puts a
  play 60 + a.to_i, sustain: 1
  sleep 0.1
  x = x + inc
end

Cu :slight_smile:

1 Like
4

And here the THX like sound :slight_smile:

use_random_seed Time.new.usec
use_synth :dsaw
f1 = 20.0
f2 = 200.0
DN = []
n = 4
slideT = 2
totalT = n * slideT * 3
for j in 0..n
  DN[j] = [:F6,:D6,:A5,:D5,:A4,:D4,:A3,:D3,:A2,:D2,:D1]
end

for i in 0 ... DN[n].length
  DN[0][i] = hz_to_midi(rrand(f1, f2))
end

for j in 1 ... n
  for i in 0 ... DN[n].length
    DN[j][i] = DN[0][i] + (DN[n][i] - DN[0][i]) / n.to_f + rrand(-n * 2 + j * 2, n * 2 - j * 2)
  end
end
with_fx :reverb, room: 1, mix: 1 do #####
  s = play DN[0], sustain: totalT, note_slide: slideT, amp: 0.1, amp_slide: slideT
  sleep slideT
  for i in 1..n
    control s, note: DN[i], amp: (i / n.to_r) + 0.5
    sleep slideT
  end
end #####

Cu.