;; synthdb.lg

to sort :data

  local [lft rght pivot next]

  if equal? 1 count data [ output data ]
  if equal? 0 count data [ output data ]	

  make "lft []
  make "rght []
  make "pivot first (first data)
  make "lft fput (first data) lft
  make "data butfirst data

  repeat count data [
    make "next first first data
    if less? next pivot [ make "rght fput (first data) rght ] 
    if equal? next pivot [ make "rght fput (first data) rght ]
    if less? pivot next [ make "lft fput (first data) lft ]
    make "data butfirst data
  ]

  make "lft sort lft
  make "rght sort rght

  output cons rght lft

end

;; believe it or not, this doesn't seem to be part of UCBLogo
to cons :list1 :list2

  if empty? list2 [ output list1 ]

  make "list1 lput first list2 list1
  make "list2 butfirst list2
  make "list1 cons list1 list2

  output list1

end


		
;; from Harvey
to tree :key :children
  local [ node ]
  output fput key children
end


;; from Harvey
to leaf :datum
  output tree data []
end


;; from Harvey
to btree :data
  if empty? data [ output [] ]
  if empty? bf data [ output data ]
  output btreehelper (int (count data)/2) data []
end


;; from Harvey
to btreehelper :c :in :out
  if equal? c 0 [
    output tree (first in) (list (btree reverse out) (btree bf in))
  ]
  output btreehelper (c-1) (bf in) (fput first in out)
end


to synth

  local [ w1 w2 w3 freq ]

  ;; add a combintion of sinusiods
  make "freq 440
  make "amp 1
  make "w1 sinewave freq
  make "i 2
  repeat 2 [
    make "w2 sinewave freq * i
    make "i i*2
    make "amp amp/1.4
    make "w2 volume w2 amp
    make "w1 combinewaves list w1 w2
  ]
  make "w2 sinewave freq/2
  make "w2 volume w2 amp/2
  make "w1 combinewaves list w1 w2

  ;; add a combintion of trianglewaves
  make "freq 430
  make "amp .6
  make "w2 trianglewave freq
  make "w2 volume w2 amp
  make "w1 combinewaves list w1 w2
  make "i 2
  repeat 2 [
    make "w2 trianglewave freq * i
    make "i i*2
    make "amp amp/1.4
    make "w2 volume w2 amp
    make "w1 combinewaves list w1 w2
  ]
  make "w2 trianglewave freq/2
  make "w2 volume w2 amp/2
  make "w1 combinewaves list w1 w2

  make "n noise 1
  make "n volume n .05
  make "w1 combinewaves list w1 n

  make "w1 normalizewave w1
  make "w1 evenwt w1

  output w1
end


to organ :base :fade
  make "wave synth
  output organhelper (base * (1 / ln 2)) :fade :wave [] 0
end


to organhelper :base :fade :wave :data :i
   local [ env note freq ]
  
   make "env list [.9 25] lput :fade [0]
   make "freq (base * (power 2 i) * (ln 2))
   if less? 2048 freq [ output data ]

   make "env list freq env
   make "note lput env [soundwt :wave]
   make "note list freq note

   make "data fput note data
   make "i i + 1/12

   output organhelper base fade wave data i

end


to organkeys :base
  make "base first :list.synth	
  make "base base * (1 / ln 2)
  make "c ascii readchar
  output (base * (power 2 (:c - 97)/12) * (ln 2))
end

to startsynth :func.synth :list.synth :func.getkey :list.getkey
  local [ freq lasttime deltatime loop cmd b ]

  make "cmd []

  make "b btree sort (apply :func.synth :list.synth)

  ;;  looping has three states 0:off and clear, 1:recording, 2:looping
  make "looping 0

  forever [
   make "key apply :func.getkey :list.getkey
    
    test equal? c 58
    iffalse [ make "cmd last lookup :key b ]
    iftrue [
      if equal? looping 2 [
        make "looping 0
      ]
      if equal? looping 1 [      
	make "looping 2
      ]
      if equal? looping 0 [
        make "lasttime time
  	make "delta 0
	make "loop []
        make "looping 1
      ]
    ]

    if equal? looping 1 [
        make "loop fput cmd :loop

        make "delta (time - lasttime)
        make "lasttime time
        make "r [rest]
        make "r lput :delta r
	make "loop fput :r :loop
    ]
    ifelse equal? looping 2 [
	test empty? loop
        iffalse [ forever [ playloop loop :wave ] ]
        make "looping 0
    ] [
      test empty? cmd
      iffalse [ 
        test equal? c 58
 	iffalse [ run cmd ]
      ]
    ]

  ]

end


to playloop :data :wave
  test empty? :data
  iffalse [
    run last :data
    playloop butlast :data :wave
  ]
end


to lookup :code :tree
  output lookuphelper :code :tree []
end


to lookuphelper :code :btree :closest
  local [ next less more ]

  make "this getNodeKey :btree

  if empty? :closest [ make "closest getNode :btree ]
  if equal? :code :this [ output getNode :btree ]
  if isleaf? :btree [ output closest ]

  ifelse less? :code :this [
    test empty? getlessbranch :btree
    iffalse [
      make "less getNodeKey getLessBranch :btree
      if updateclosest? :code :less first closest [ 
        make "closest getNode getLessBranch :btree 
      ]
      test isleaf? getLessBranch :btree
      iffalse [ make "closest lookuphelper :code getLessBranch :btree :closest ]
    ]
  ] [
    test empty? getmorebranch :btree
    iffalse [
      make "more getNodeKey getMoreBranch :btree
      if updateclosest? :code :more first closest [ 
        make "closest getNode getMoreBranch :btree 
      ]
      test isleaf? getMoreBranch :btree 
      iffalse [ make "closest lookuphelper :code getMoreBranch :btree :closest ]
    ]
  ]

  output closest
end


to updateclosest? :code :next :current
  output less? abs (code - next) abs (code - current)
end


to isleaf? :x
  output less? count :x 2
end	


to abs :x
  ifelse less? x 0 [ output minus x ] [ output x ]
end


to getNode :btree
  output first :btree
end


to getNodeKey :btree
  output first first :btree
end


to getNodeValue :btree
  output last first :btree
end


to getLessBranch :btree
  output first butfirst :btree
end


to getMoreBranch :btree
  output last :btree
end