packages feed

hsc3-graphs (empty) → 0.8

raw patch · 101 files changed

+3932/−0 lines, 101 filesdep +arraydep +basedep +hoscsetup-changed

Dependencies added: array, base, hosc, hsc3, hsc3-sf, process, random

Files

+ README view
@@ -0,0 +1,11 @@+hsc3-graphs - haskell supercollider graphs++hsc3-graphs provides a collection of illustrative +unit generator graphs for hsc3.++  http://slavepianos.org/rd/?t=hsc3-graphs+  http://haskell.org/+  http://audiosynth.com/++(c) rohan drape and others, 2006-2010+    gpl, http://gnu.org/copyleft/
+ Setup.lhs view
@@ -0,0 +1,3 @@+#!/usr/bin/env runhaskell+> import Distribution.Simple+> main = defaultMain
+ hsc3-graphs.cabal view
@@ -0,0 +1,413 @@+Name:              hsc3-graphs+Version:           0.8+Synopsis:          Haskell SuperCollider Graphs+Description:       hsc3-graphs provides a collection of illustrative +                   unit generator graphs for hsc3.+License:           GPL+Category:          Sound+Copyright:         (c) Rohan Drape and others, 2006-2010+Author:            Rohan Drape+Maintainer:        rd@slavepianos.org+Stability:         Experimental+Homepage:          http://slavepianos.org/rd/?t=hsc3-graphs+Tested-With:       GHC == 6.10.3+Build-Type:        Simple+Cabal-Version:     >= 1.6++Data-files:        README++Executable         hsc3-adso+ main-is:          src/adso.lhs+ build-depends:    base==4.*, hosc==0.8, hsc3==0.8, random++Executable         hsc3-aleatoric-quartet+ main-is:          src/aleatoric-quartet.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-analog-bubbles+ main-is:          src/analog-bubbles.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-babbling-brook+ main-is:          src/babbling-brook.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-birds+ main-is:          src/birds.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-bit-reduction+ main-is:          src/bit-reduction.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-bottle+ main-is:          src/bottle.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-bowed-string+ main-is:          src/bowed-string.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-ccomb+ main-is:          src/ccomb.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-chain-saw+ main-is:          src/chain-saw.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-chrd+ main-is:          src/chrd.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-cricket+ main-is:          src/cricket.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-crotale+ main-is:          src/crotale.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-cut-outs+ main-is:          src/cut-outs.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-cymbalism+ main-is:          src/cymbalism.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-deep-sea+ main-is:          src/deep-sea.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-default+ main-is:          src/default.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-demanding-studies+ main-is:          src/demanding-studies.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-dial-history+ main-is:          src/dial-history.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-diffraction+ main-is:          src/diffraction.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-discretion+ main-is:          src/discretion.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-drummer+ main-is:          src/drummer.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-eggcrate+ main-is:          src/eggcrate.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-e-lamell+ main-is:          src/e-lamell.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-fbl-fbf+ main-is:          src/fbl-fbf.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-feedr+ main-is:          src/feedr.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-f-lets+ main-is:          src/f-lets.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-fm-iter+ main-is:          src/fm-iter.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-fm-kltr+ main-is:          src/fm-kltr.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-forest-sounds+ main-is:          src/forest-sounds.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-fwalk+ main-is:          src/fwalk.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-half-life+ main-is:          src/half-life.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-harmonic-swimming+ main-is:          src/harmonic-swimming.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-harmonic-tumbling+ main-is:          src/harmonic-tumbling.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-h-chatter+ main-is:          src/h-chatter.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-hh-808+ main-is:          src/hh-808.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-implosion+ main-is:          src/implosion.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-insects+ main-is:          src/insects.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-karplus-strong+ main-is:          src/karplus-strong.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-klink+ main-is:          src/klink.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-k-ppr+ main-is:          src/k-ppr.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-lfo-modulation+ main-is:          src/lfo-modulation.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-lf-pulses+ main-is:          src/lf-pulses.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-lg-timed+ main-is:          src/lg-timed.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-lin-sosc+ main-is:          src/lin-sosc.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-lucier+ main-is:          src/lucier.hs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-modal-space+ main-is:          src/modal-space.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-moto-rev+ main-is:          src/moto-rev.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-mouse-clatter+ main-is:          src/mouse-clatter.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-nharm+ main-is:          src/nharm.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-noise-burst-sweep+ main-is:          src/noise-burst-sweep.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-non-real-time+ main-is:          src/non-real-time.hs+ build-depends:    base==4.*, hosc==0.8, hsc3==0.8, process++Executable         hsc3-one-line+ main-is:          src/one-line.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-oscillator-cluster+ main-is:          src/oscillator-cluster.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-overlap-add+ main-is:          src/overlap-add.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-pattern-buffer+ main-is:          src/pattern-buffer.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-plucked-strings+ main-is:          src/plucked-strings.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-police-state+ main-is:          src/police-state.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-pulsing-bottles+ main-is:          src/pulsing-bottles.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-record-scratcher+ main-is:          src/record-scratcher.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-red-frik+ main-is:          src/red-frik.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-reset+ main-is:          src/reset.hs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-reverberated-sine-percussion+ main-is:          src/reverberated-sine-percussion.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-rm-octaver+ main-is:          src/rm-octaver.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-sample-and-hold-liquidities+ main-is:          src/sample-and-hold-liquidities.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-s-chirp+ main-is:          src/s-chirp.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-scratchy+ main-is:          src/scratchy.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-scratchy-m+ main-is:          src/scratchy-m.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-scritto+ main-is:          src/scritto.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-shepard-tones+ main-is:          src/shepard-tones.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-shifting-pulses+ main-is:          src/shifting-pulses.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-snare-909+ main-is:          src/snare-909.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-sosc-lp+ main-is:          src/sosc-lp.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-spe+ main-is:          src/spe.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-sprinkler+ main-is:          src/sprinkler.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-sprinkler-m+ main-is:          src/sprinkler-m.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-strummable-guitar+ main-is:          src/strummable-guitar.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-sweepy-noise+ main-is:          src/sweepy-noise.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-synthetic-piano+ main-is:          src/synthetic-piano.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-tank+ main-is:          src/tank.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-tgb+ main-is:          src/tgb.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-tgrn+ main-is:          src/tgrn.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-tgr-rpr+ main-is:          src/tgr-rpr.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-theremin+ main-is:          src/theremin.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-three-cpsw+ main-is:          src/three-cpsw.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-thx+ main-is:          src/thx.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-tipnso+ main-is:          src/tipnso.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-train+ main-is:          src/train.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-trkl+ main-is:          src/trkl.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-tr-out+ main-is:          src/tr-out.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-tsort+ main-is:          src/tsort.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-vlc-distrtn+ main-is:          src/vlc-distrtn.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-waveset+ main-is:          src/waveset.hs+ build-depends:    array, base==4.*, hosc==0.8, hsc3==0.8, hsc3-sf==0.8, random++Executable         hsc3-what-was-i-thinking+ main-is:          src/what-was-i-thinking.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-wial+ main-is:          src/wial.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-wind-metals+ main-is:          src/wind-metals.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-xy-interference+ main-is:          src/xy-interference.lhs+ build-depends:    base==4.*, hsc3==0.8++Executable         hsc3-xy-interference-m+ main-is:          src/xy-interference-m.lhs+ build-depends:    base==4.*, hsc3==0.8++Source-Repository  head+  Type:            darcs+  Location:        http://slavepianos.org/~rd/sw/hsc3-graphs/
+ src/adso.lhs view
@@ -0,0 +1,34 @@+adso (rd)++> import Sound.OpenSoundControl+> import Sound.SC3+> import System.Random++> main =+>   let { rrand l r = getStdRandom (randomR (l, r))+>       ; rrand_l j l r = sequence (replicate j (rrand l r))+>       ; n = 24+>       ; adso = let { get b j = let k = mce [0 .. constant j - 1]+>                                in bufRdN 1 kr b k NoLoop+>                    ; m = sinOsc kr (get 3 n) 0+>                    ; f = midiCPS (get 0 n) * (m * get 4 n + 1)+>                    ; l = get 2 n+>                    ; g = get 1 n }+>                in out 0 (mix (pan2 (sinOsc ar f 0) l g))+>       ; pattern fd t = do { z <- do { l <- rrand 22 48+>                                     ; r <- rrand 54 122+>                                     ; sequence (replicate n (rrand l r)) }+>                           ; send fd (b_setn1 0 0 z)+>                           ; let rn i l r = do { d <- rrand_l n l r+>                                               ; send fd (b_setn1 i 0 d) }+>                             in do { rn 1 0 0.1+>                                   ; rn 2 (-1) 1+>                                   ; rn 3 2 12+>                                   ; rn 4 0.001 0.0075+>                                   ; rn 5 1 24+>                                   ; rn 6 0.05 2.4 }+>                           ; pauseThread t } }+>   in withSC3 (\fd ->   do { mapM_ (\i ->   async fd (b_alloc i n 1)) [0..6]+>                         ; play fd adso+>                         ; mapM_ (pattern fd) =<< rrand_l 32 0.025 0.75+>                         ; reset fd })
+ src/aleatoric-quartet.lhs view
@@ -0,0 +1,52 @@+aleatoric quartet (jmcc)++> import Sound.SC3.Monadic++> main = +>   let { base_mn = control KR "note" 66+>       ; amp = control KR "ampl" 0.07+>       ; density = mouseX kr 0.01 1 Linear 0.1+>       ; dmul = recip density * 0.5 * amp+>       ; dadd = amp - dmul+>       ; (>=>) f g = \x ->   f x >>= g+>       ; chain n f = foldl (>=>) return (replicate n f)+>       ; rapf i = do { r <- clone 2 (rand 0 0.05)+>                     ; return (allpassN i 0.05 r 1) }+>       ; mk_f = do { i0 <- iRand 0 2+>                   ; let r0 = select i0 (mce [1, 0.5, 0.25])+>                     in do { r1 <- rand (-30) 30+>                           ; n0 <- lfNoise0 kr r0+>                           ; let { m = n0 * 7 + base_mn + r1+>                                 ; m' = lag (roundE m 1) 0.2 }+>                             in return (midiCPS m) } }+>       ; mk_s = do { f <- fmap recip mk_f+>                   ; r <- rand (-1) 1+>                   ; x <- do { n0 <- pinkNoise ar+>                             ; n1 <- lfNoise1 kr 8+>                             ; return (n0 * max 0 (n1 * dmul + dadd)) }+>                   ; return (pan2 (combL x 0.02 f 3) r 1) } }+>   in do { g <- chain 5 rapf =<< fmap sum (sequence (replicate 4 mk_s))+>         ; audition (out 0 (leakDC g 0.995)) }++{ var amp = 0.07+; var density = MouseX.kr(0.01, 1, 'linear', 0.1)+; var dmul = density.reciprocal * 0.5 * amp+; var dadd = amp - dmul+; var rapf = { arg i+             ; var r = Array.fill(2, { Rand(0, 0.05) })+             ; AllpassN.ar(i, 0.05, r, 1) }+; var mk_f = { var i0 = IRand.new(0, 2)+             ; var r0 = Select.kr(i0, [1, 0.5, 0.25])+             ; var r1 = Rand.new(-30, 30)+             ; var n0 = LFNoise0.kr(r0)+             ; var m = Lag.kr((n0 * 7 + 66 + r1).round(1), 0.2)+             ; m.midicps }+; var mk_s = { var f = mk_f.value.reciprocal+             ; var r = Rand.new(-1, 1)+             ; var n0 = PinkNoise.ar()+             ; var n1 = LFNoise1.kr(8)+             ; var x = n0 * 0.max(n1 * dmul + dadd)+             ; Pan2.ar(CombL.ar(x, 0.02, f, 3), r, 1) }+; var g = Mix.fill(4, mk_s)+; 5.do({ g = rapf.value(g) })+; Out.ar(0, LeakDC.ar(g, 0.995)) }.play
+ src/analog-bubbles.lhs view
@@ -0,0 +1,14 @@+analog bubbles (jmcc)++> import Sound.SC3++> main =+>   let { o = lfSaw kr (mce2 8 7.23) 0 * 3 + 80+>       ; f = lfSaw kr 0.4 0 * 24 + o+>       ; s = sinOsc ar (midiCPS f) 0 * 0.04 }+>   in audition (out 0 (combN s 0.2 0.2 4))++{ var o = LFSaw.kr([8, 7.23], 0, 3, 80)+; var f = LFSaw.kr(0.4, 0, 24, o)+; var s = SinOsc.ar(f.midicps, 0, 0.04)+; Out.ar(0, CombN.ar(s, 0.2, 0.2, 4)) }.play
+ src/babbling-brook.lhs view
@@ -0,0 +1,23 @@+babbling brook (jmcc)++> import Sound.SC3.Monadic++> main = +>   let b f m a g = do { n1 <- brownNoise ar+>                      ; n2 <- brownNoise ar+>                      ; let { n3 = lpf n2 f * m + a+>                            ; n4 = onePole n1 0.99 }+>                        in return (rhpf n4 n3 0.03 * g) }+>   in do { x <- clone 2 (b 14 400 500 0.006)+>         ; y <- clone 2 (b 20 800 1000 0.010)+>         ; audition (out 0 (x + y)) }++{ var b = { arg f, m, a, g +          ; { var n1 = OnePole.ar(BrownNoise.ar, 0.99)+            ; var n2 = LPF.ar(BrownNoise.ar, f) +            ; RHPF.ar(n1, n2 * m + a, 0.03, g) } }+; var x = b.value(14, 400, 500, 0.006) ! 2+; var y = b.value(20, 800, 1000, 0.010) ! 2+; Out.ar(0, x + y) }.play++http://lists.create.ucsb.edu/pipermail/sc-users/2007-April/033239.html
+ src/birds.lhs view
@@ -0,0 +1,28 @@+birds (jmcc)++> import Sound.SC3.Monadic++> main =+>   let { node = do { r1 <- rand 94.0 102.0+>                   ; r2 <- rand (-1.5) 1.5+>                   ; r3 <- rand 0.0 1.0+>                   ; r4 <- rand 11.0 15.0+>                   ; r5 <- rand 0.0 1.0+>                   ; r6 <- rand 12.0 15.6+>                   ; r7 <- rand 0.0 1.0+>                   ; r8 <- rand (-1.0) 1.0+>                   ; let { f = r1 + lag (lfSaw AR (7 + r2) r3 * r4) 0.1+>                         ; a = lfPulse KR (1.0 / r6) r7 0.16 * 0.05+>                         ; b = sinOsc AR (midiCPS f) r5 * a } +>                     in return (rotate2 b (silent 1) r8) }+>       ; apf i = do { r1 <- rand 0.0 0.06+>                    ; r2 <- rand 0.7 2.0+>                    ; return (allpassL i 0.07 r1 r2) }+>       ; composeM [] i = return i+>       ; composeM (f:fs) i = f =<< composeM fs i+>       ; chainM n f = composeM (replicate n f) }+>   in do { d <- return . sum =<< sequence (replicate 6 node)+>         ; w <- chainM 12 apf d+>         ; audition (out 0 (d * 0.7 + w * 0.3)) }++http://lists.create.ucsb.edu/pipermail/sc-users/2007-April/033239.html
+ src/bit-reduction.lhs view
@@ -0,0 +1,37 @@+bit reduction (adc)++> import Sound.SC3.Monadic++> sample_rate_decrease =+>   do { f <- lfNoise2 kr 8+>      ; nh <- lfNoise2 kr 3+>      ; let { src = blip ar (f * 200 + 300) (nh * 10 + 20)+>            ; sr = mouseX kr 1000 (sampleRate * 0.1) Exponential 0.2 }+>        in audition (out 0 (latch src (impulse ar sr 0))) }++{ var f = LFNoise2.kr(8)+; var nh = LFNoise2.kr(3)+; var src = Blip.ar(f * 200 + 300, nh * 10 + 20)+; var sr = MouseX.kr(1000, s.sampleRate * 0.1, 'exponential', 0.2)+; Out.ar(0, Latch.ar(src, Impulse.ar(sr, 0))) }.play++> bit_rate_decrease =+>   do { f <- lfNoise2 kr 8+>      ; nh <- lfNoise2 kr 3+>      ; let { src = blip ar (f * 200 + 300) (nh * 10 + 20)+>            ; sr = mouseX kr 1000 (sampleRate * 0.1) Exponential 0.2+>            ; bit_sz = mouseY kr 1 24 Exponential 0.2+>            ; down_sample = latch src (impulse ar sr 0)+>            ; bit_redux = roundE down_sample (0.5 ** bit_sz) }+>        in audition (out 0 (mce2 down_sample bit_redux)) }++{ var f = LFNoise2.kr(8)+; var nh = LFNoise2.kr(3)+; var src = Blip.ar(f * 200 + 300, nh * 10 + 20)+; var sr = MouseX.kr(1000, s.sampleRate * 0.1, 'exponential', 0.2)+; var bit_sz = MouseY.kr(1, 24, 'exponential', 0.2) +; var down_sample = Latch.ar(src, Impulse.ar(sr, 0))+; var bit_redux = down_sample.round(0.5 ** bit_sz)+; Out.ar(0, [down_sample, bit_redux]) }.play++> main = bit_rate_decrease
+ src/bottle.lhs view
@@ -0,0 +1,23 @@+bottle (sc)++> import Sound.SC3.Monadic++> main =+>   do { freq <- rand 220 880+>      ; wn <- whiteNoise ar+>      ; pn <- pinkNoise ar+>      ; let { (>=>) f g = \x -> f x >>= g+>            ; chain n f = foldl (>=>) return (replicate n f)+>            ; perc = envPerc 0.1 0.6+>            ; ex = envGen kr 1 1 0 1 DoNothing perc * wn * 0.02+>            ; flute = ringz ex freq 0.3+>            ; r = resonz pn (5 + (freq / 2)) 0.1+>            ; breath = envGen kr 1 1 0 1 DoNothing perc * r+>            ; rapf i = do { x <- linRand 0.001 0.1 (-1)+>                          ; return (i + allpassN i 0.1 x 1.0 * 0.5) }+>            ; cls i = let { en = let c = EnvNum (-4) in (c,c,c)+>                          ; l = envLinen' 0.01 3.0 1.0 1 en+>                          ; z = (breath + i) * envGen kr 1 1 0 1 RemoveSynth l }+>                      in mce2 z z }+>        in do { f <- (chain 2 rapf) flute+>              ; audition (out 0 (cls f)) } }
+ src/bowed-string.lhs view
@@ -0,0 +1,38 @@+bowed string (jmcc)++> import Control.Monad+> import Sound.SC3.Monadic+> import System.Random++> main =+>     let { rrand l r = getStdRandom (randomR (l, r))+>         ; choose l = fmap (l !!) (rrand 0 (length l - 1))+>         ; root = 5+>         ; scale = map (+ root) [0, 2, 4, 5, 7, 9, 11]+>         ; oct = [24, 36, 48, 60, 72, 84] }+>   in do { n0 <- clone 2 (brownNoise ar)+>         ; r0 <- expRand 0.125 0.5+>         ; r1 <- rand 0.7 0.9+>         ; r2 <- sequence (replicate 12 (rand 1.0 3.0))+>         ; f <- fmap midiCPS (liftM2 (+) (choose scale) (choose oct))+>         ; n1 <- lfNoise1 kr r0+>         ; let { x = n0 * 0.007 * max 0 (n1 * 0.6 + 0.4)+>               ; geom n i z = take n (iterate (* z) i)+>               ; iota n i z = take n (iterate (+ z) i)+>               ; d = klankSpec (iota 12 f f) (geom 12 1 r1) r2+>               ; k = klank x 1 0 1 d }+>         in audition (out 0 (softClip (k * 0.1))) }++{ var root = 5+; var scale = #[0, 2, 4, 5, 7, 9, 11] + root+; var oct = #[24, 36, 48, 60, 72, 84]+; var f = (scale.choose + oct.choose).midicps+; var n0 = BrownNoise.ar().dup+; var r0 = ExpRand.new(0.125, 0.5)+; var n1 = LFNoise1.kr(r0)+; var r1 = Rand.new(0.7,0.9)+; var r2 = Array.fill(12, { Rand.new(1.0, 3.0) })+; var x = n0 * 0.007 * max(0, n1 * 0.6 + 0.4)+; var d = `[Array.series(12, f, f), Array.geom(12, 1, r1), r2]+; var k = Klank.ar(d, x)+; Out.ar(0, (k * 0.1).softclip) }.play
+ src/ccomb.lhs view
@@ -0,0 +1,28 @@+ccomb (rd)++> import Sound.SC3.Monadic++> main =+>   let { rng l r i = linLin i (-1) 1 l r+>       ; lwr = 48+>       ; flwr = midiCPS lwr+>       ; spart t = do { n <- fmap (rng lwr 72.0) (lfNoise2 kr 0.1)+>                      ; e <- fmap (decay2 t 0.01) (tRand 0.05 0.75 t)+>                      ; x <- fmap (* e) (whiteNoise ar)+>                      ; m <- lfNoise2 kr 0.1+>                      ; let f = lag (midiCPS n) 0.25+>                        in return (combC x (recip flwr) (recip f) (rng 1 8 m)) } }+>   in do { t <- dust kr (mce2 0.75 0.35)+>         ; audition . (out 0) . (* 0.1) . sum =<< sequence (replicate 12 (spart t)) }++{ var lwr = 48+; var flwr = lwr.midicps+; var spart = { arg t+              ; { var n = LFNoise2.kr(0.1).range(lwr, 72.0)+                ; var e = Decay2.kr(t, 0.01, TRand.kr(0.05, 0.75, t))+                ; var x = WhiteNoise.ar() * e+                ; var m = LFNoise2.kr(0.1)+                ; var f = Lag.kr(n.midicps, 0.25)+                ; CombC.ar(x, flwr.reciprocal, f.reciprocal, m.range(1, 8)) } }+; var t = Dust.kr([0.75, 0.35])+; Out.ar(0, Mix.fill(12, spart.value(t)) * 0.1) }.play
+ src/chain-saw.lhs view
@@ -0,0 +1,56 @@+chain saw (jrhb)++[this graph generates long chains of unit generators and may require+increasing the stack limit of the haskell run time system]++> import Control.Monad+> import Sound.SC3.Monadic+> import System.Random++> main =+>    let { rrand l r = getStdRandom (randomR (l, r)) :: IO Double+>        ; coin n a b = do { m <- rrand 0.0 1.0+>                          ; return (if m > n then a else b) }+>        ; exprange s l r = linExp s (-1) 1 l r+>        ; chain n fn = foldr (<=<) return (replicate n fn)+>        ; mceProduct = mceEdit (\l -> [product l])+>        ; clipu s = clip2 s 1+>        ; dup a = mce2 a a+>        ; f s1 = do { xr <- fmap dup (expRand 0.1 2)+>                    ; n1 <- lfNoise1 kr xr+>                    ; n2 <- lfNoise1 kr xr+>                    ; n3 <- lfNoise1 kr xr+>                    ; f1 <- coin 0.6 (exprange n1 0.01 10) (exprange n2 10 50)+>                    ; s2 <- coin 0.5 (1 - s1) (mceReverse s1)+>                    ; let { f2 = linExp s1 (-1) 1 f1 (f1 * exprange n3 2 10)+>                          ; u1 = lfSaw kr f2 0+>                          ; u2 = lfSaw kr (f1 * 0.1) 0 * 0.1 + 1 }+>                   in return . clipu =<< coin 0.5 (u1 * s2) (u1 * u2) }+>        ; inp = lfSaw kr (0.2 * mce2 1 1.1) 0+>        ; b_freq = mce [70, 800, 9000, 5242] }+>   in do { ff <- chain 8 f inp+>         ; let { c_saw = mceProduct (saw ar (exprange ff 6 11000))+>               ; b_saw = dup (mix (bpf c_saw b_freq 0.2)) }+>         in audition (out 0 (b_saw * 0.3)) }++{ var f = { arg s1+          ; var rate = ExpRand.new(0.1, 2).dup+          ; var n1 = { LFNoise1.kr(rate).exprange(0.01, 10) }+          ; var n2 = { LFNoise1.kr(rate).exprange(10, 50) }+          ; var n3 = LFNoise1.kr(rate).exprange(2, 10)+          ; var f1 = if(0.6.coin) { n1.value } { n2.value }+          ; var s2 = [1 - s1, s1.reverse].choose+          ; var f2 = LinExp.kr(s1, -1, 1, f1, f1 * n3)+          ; var u1 = LFSaw.kr(f2, 0)+          ; var u2 = LFSaw.kr(f1 * 0.1, 0, 0.1, 1)+          ; var u3 = if(0.5.coin) { u1 * s2 } { u1 * u2 }+          ; u3.clip2(1) }+; var g = { arg func, n+          ; n.do { func = func <> func }+          ; func }+; var inp = LFSaw.kr(0.2 * [1, 1.1], 0)+; var b_freq = [70, 800, 9000, 5242]+; var ff = g.(f, 4).value(inp)+; var c_saw = Saw.ar(ff.exprange(6, 11000)).product+; var b_saw = BPF.ar(c_saw, b_freq, 0.2).sum.dup+; Out.ar(0, b_saw * 0.3) }.play
+ src/chrd.lhs view
@@ -0,0 +1,36 @@+chrd (rd)++> import Sound.SC3.Monadic++> main =+>   let chrd = do { r0 <- rand 0.05 0.5+>                 ; [r1, r2] <- sequence (replicate 2 (rand (-1) 1))+>                 ; r3 <- rand 0.15 0.35+>                 ; r4 <- rand 0.005 0.01+>                 ; let { m = mce [60, 65, 72, 77, 79, 84]+>                       ; ds = 3+>                       ; d = mce (map (* ds) [5, 4, 5, 7, 4, 5])+>                       ; f = midiCPS (xLine kr m (m + r0) d DoNothing)+>                       ; z = envTrapezoid 0 r3 d r4+>                       ; e = envGen kr 1 1 0 1 DoNothing z+>                       ; p = xLine kr r1 r2 d DoNothing+>                       ; o = fSinOsc ar f 0 }+>                   in return (mix (pan2 o p e)) }+>   in audition . out 0 . mix =<< clone 9 chrd++{ var chrd = { var r0 = Rand.new(0.05, 0.5)+             ; var r1 = Rand.new(-1, 1)+             ; var r2 = Rand.new(-1, 1)+             ; var r3 = Rand.new(0.15, 0.35)+             ; var r4 = Rand.new(0.005, 0.01)+             ; var m = [60, 65, 72, 77, 79, 84]+             ; var ds = 3+             ; var d = [5, 4, 5, 7, 4, 5] * ds+             ; var f = XLine.kr(m, m + r0, d).midicps+             ; var z_ = Env.linen(r3 * d, 0, (1 - r3) * d, r4)+             ; var z = Env.sine(d.maxItem, r4)+             ; var e = EnvGen.kr(z, 1, 1, 0, 1)+             ; var p = XLine.kr(r1, r2, d)+             ; var o = SinOsc.ar(f, 0)+             ; Mix.ar(Pan2.ar(o, p, e)) }+; Out.ar(0, Mix.fill(9, chrd)) }.play
+ src/cricket.lhs view
@@ -0,0 +1,22 @@+cricket (rd)++> import Sound.SC3.Monadic++> main =+>   do { r1 <- clone 2 (rand 10 13)+>      ; r2 <- clone 2 (rand 10 13)+>      ; r3 <- clone 2 (rand 4 7)+>      ; let { t = impulse kr 0.7 0+>            ; e = decay2 (impulse kr r1 0) 0.001 0.005+>            ; f = sinOsc kr r2 0 * e * r3 }+>        in do { r4 <- clone 2 (tRand 2220 2227 t)+>              ; audition (out 0 (sinOsc ar r4 0 * f * 0.25)) } }++{ var r1 = Array.fill(2, { Rand.new(10, 13) })+; var r2 = Array.fill(2, { Rand.new(10, 13) })+; var r3 = Array.fill(2, { Rand.new(4, 7) })+; var t = Impulse.kr(0.7, 0)+; var e = Decay2.kr(Impulse.kr(r1, 0), 0.001, 0.005)+; var f = SinOsc.kr(r2, 0) * e * r3+; var r4 = Array.fill(2, { TRand.kr(2220, 2227, t) })+; Out.ar(0, SinOsc.ar(r4, 0) * f * 0.25) }.play
+ src/crotale.lhs view
@@ -0,0 +1,333 @@+crotale (rd)++> import Sound.SC3.ID++> main =+>     let { crotale = ( [ 35.45676040649414+>                       , 128.59849548339844+>                       , 346.9721984863281+>                       , 483.5544128417969+>                       , 1049.2449951171875+>                       , 1564.0279541015625+>                       , 1756.3399658203125+>                       , 3391.666015625+>                       , 3451.802001953125+>                       , 3497.261962890625+>                       , 3596.89794921875+>                       , 3696.739013671875+>                       , 3835.235107421875+>                       , 3845.955078125+>                       , 4254.85107421875+>                       , 4407.533203125+>                       , 4415.26416015625+>                       , 4552.865234375+>                       , 5538.076171875+>                       , 5637.73681640625+>                       , 5690.2978515625+>                       , 5728.0068359375+>                       , 5764.27685546875+>                       , 5824.4189453125+>                       , 6377.60498046875+>                       , 6544.35009765625+>                       , 6807.14404296875+>                       , 6994.97021484375+>                       , 7026.84619140625+>                       , 7144.5859375+>                       , 7269.61279296875+>                       , 7393.6708984375+>                       , 7897.259765625+>                       , 8040.4580078125+>                       , 8157.77099609375+>                       , 8225.01953125+>                       , 9126.150390625+>                       , 9488.529296875+>                       , 9916.408203125+>                       , 10155.599609375+>                       , 11715.9599609375+>                       , 12111.830078125+>                       , 12339.990234375+>                       , 12417.669921875+>                       , 12459.2802734375+>                       , 12618.330078125+>                       , 13116.490234375+>                       , 13201.1298828125+>                       , 13297.830078125+>                       , 13533.75 ]+>                     , [ 0.0012827360769733787+>                       , 0.0008040848188102245+>                       , 0.017361238598823547+>                       , 0.004835359752178192+>                       , 0.004413491114974022+>                       , 0.004110544919967651+>                       , 0.0003338181704748422+>                       , 0.0036140112206339836+>                       , 0.006919348146766424+>                       , 0.0003224937245249748+>                       , 0.0006031467346474528+>                       , 0.06686479598283768+>                       , 0.000605064386036247+>                       , 0.003602313343435526+>                       , 0.0002835785271599889+>                       , 0.015243238769471645+>                       , 0.020536603406071663+>                       , 0.016677580773830414+>                       , 0.0009245267719961703+>                       , 0.20205098390579224+>                       , 0.0012542791664600372+>                       , 0.012705927714705467+>                       , 0.0002523190632928163+>                       , 0.0004866079252678901+>                       , 0.0006429700297303498+>                       , 0.0007763264584355056+>                       , 0.2081160992383957+>                       , 0.0024918108247220516+>                       , 0.00193469924852252+>                       , 0.005231771152466536+>                       , 0.0069242212921381+>                       , 0.001203975174576044+>                       , 0.2050020843744278+>                       , 0.04060448706150055+>                       , 0.0038344631902873516+>                       , 0.002189427148550749+>                       , 0.18056060373783112+>                       , 0.002192433224990964+>                       , 0.006516554858535528+>                       , 0.009982921183109283+>                       , 0.004745401442050934+>                       , 0.046154771000146866+>                       , 0.000510294979903847+>                       , 0.0018905038014054298+>                       , 0.0019782145973294973+>                       , 0.006729386281222105+>                       , 0.0023426134139299393+>                       , 0.0024002245627343655+>                       , 0.03515550494194031+>                       , 0.0014084168942645192 ]+>                     , [ 5.203680992126465+>                       , 1.7034343481063843+>                       , 40.16516876220703+>                       , 27.282501220703125+>                       , 0.8950523138046265+>                       , 42.84742736816406+>                       , 2.6603667736053467+>                       , 15.7678861618042+>                       , 6.848367214202881+>                       , 3.2325007915496826+>                       , 1.7343382835388184+>                       , 2.0202419757843018+>                       , 4.7279052734375+>                       , 9.400103569030762+>                       , 0.7102512717247009+>                       , 37.494625091552734+>                       , 36.24879455566406+>                       , 29.172658920288086+>                       , 3.891019344329834+>                       , 4.757885456085205+>                       , 3.851426124572754+>                       , 20.90781021118164+>                       , 3.732874870300293+>                       , 2.3834102153778076+>                       , 10.443285942077637+>                       , 8.795611381530762+>                       , 20.98564338684082+>                       , 18.01180076599121+>                       , 25.297883987426758+>                       , 14.819819450378418+>                       , 42.39189910888672+>                       , 2.9485135078430176+>                       , 11.043763160705566+>                       , 49.55165100097656+>                       , 29.882694244384766+>                       , 10.527188301086426+>                       , 23.5572452545166+>                       , 26.55561637878418+>                       , 45.099605560302734+>                       , 22.550390243530273+>                       , 36.46126174926758+>                       , 11.826201438903809+>                       , 16.818185806274414+>                       , 14.903121948242188+>                       , 32.81113815307617+>                       , 43.1389045715332+>                       , 12.289558410644531+>                       , 11.498942375183105+>                       , 10.465788841247559+>                       , 24.93169593811035 ] )+>         ; (cf, ca, cd) = crotale+>         ; ps = mce [-12, -5, 0, 2, 4, 5, 7, 12]+>         ; n = pinkNoise 'a' ar+>         ; t = dust 'a' kr 3+>         ; fs = select (tiRand 'a' 0 7 t) ps+>         ; g = tRand 'a' 0 1 t+>         ; fo = tRand 'b' 0 1 t+>         ; ds = tRand 'c' 2 7 t+>         ; p = tRand 'd' (-1) 1 t+>         ; s = decay2 t 0.06 0.01 * n * g+>         ; ks = klankSpec cf ca (map recip cd)+>         ; k = dynKlank s (midiRatio fs) fo ds ks }+>   in audition (out 0 (pan2 k p 1))++{ var crotale = [ [ 35.45676040649414+                  , 128.59849548339844+                  , 346.9721984863281+                  , 483.5544128417969+                  , 1049.2449951171875+                  , 1564.0279541015625+                  , 1756.3399658203125+                  , 3391.666015625+                  , 3451.802001953125+                  , 3497.261962890625+                  , 3596.89794921875+                  , 3696.739013671875+                  , 3835.235107421875+                  , 3845.955078125+                  , 4254.85107421875+                  , 4407.533203125+                  , 4415.26416015625+                  , 4552.865234375+                  , 5538.076171875+                  , 5637.73681640625+                  , 5690.2978515625+                  , 5728.0068359375+                  , 5764.27685546875+                  , 5824.4189453125+                  , 6377.60498046875+                  , 6544.35009765625+                  , 6807.14404296875+                  , 6994.97021484375+                  , 7026.84619140625+                  , 7144.5859375+                  , 7269.61279296875+                  , 7393.6708984375+                  , 7897.259765625+                  , 8040.4580078125+                  , 8157.77099609375+                  , 8225.01953125+                  , 9126.150390625+                  , 9488.529296875+                  , 9916.408203125+                  , 10155.599609375+                  , 11715.9599609375+                  , 12111.830078125+                  , 12339.990234375+                  , 12417.669921875+                  , 12459.2802734375+                  , 12618.330078125+                  , 13116.490234375+                  , 13201.1298828125+                  , 13297.830078125+                  , 13533.75 ]+                , [ 0.0012827360769733787+                  , 0.0008040848188102245+                  , 0.017361238598823547+                  , 0.004835359752178192+                  , 0.004413491114974022+                  , 0.004110544919967651+                  , 0.0003338181704748422+                  , 0.0036140112206339836+                  , 0.006919348146766424+                  , 0.0003224937245249748+                  , 0.0006031467346474528+                  , 0.06686479598283768+                  , 0.000605064386036247+                  , 0.003602313343435526+                  , 0.0002835785271599889+                  , 0.015243238769471645+                  , 0.020536603406071663+                  , 0.016677580773830414+                  , 0.0009245267719961703+                  , 0.20205098390579224+                  , 0.0012542791664600372+                  , 0.012705927714705467+                  , 0.0002523190632928163+                  , 0.0004866079252678901+                  , 0.0006429700297303498+                  , 0.0007763264584355056+                  , 0.2081160992383957+                  , 0.0024918108247220516+                  , 0.00193469924852252+                  , 0.005231771152466536+                  , 0.0069242212921381+                  , 0.001203975174576044+                  , 0.2050020843744278+                  , 0.04060448706150055+                  , 0.0038344631902873516+                  , 0.002189427148550749+                  , 0.18056060373783112+                  , 0.002192433224990964+                  , 0.006516554858535528+                  , 0.009982921183109283+                  , 0.004745401442050934+                  , 0.046154771000146866+                  , 0.000510294979903847+                  , 0.0018905038014054298+                  , 0.0019782145973294973+                  , 0.006729386281222105+                  , 0.0023426134139299393+                  , 0.0024002245627343655+                  , 0.03515550494194031+                  , 0.0014084168942645192 ]+                , [ 5.203680992126465+                  , 1.7034343481063843+                  , 40.16516876220703+                  , 27.282501220703125+                  , 0.8950523138046265+                  , 42.84742736816406+                  , 2.6603667736053467+                  , 15.7678861618042+                  , 6.848367214202881+                  , 3.2325007915496826+                  , 1.7343382835388184+                  , 2.0202419757843018+                  , 4.7279052734375+                  , 9.400103569030762+                  , 0.7102512717247009+                  , 37.494625091552734+                  , 36.24879455566406+                  , 29.172658920288086+                  , 3.891019344329834+                  , 4.757885456085205+                  , 3.851426124572754+                  , 20.90781021118164+                  , 3.732874870300293+                  , 2.3834102153778076+                  , 10.443285942077637+                  , 8.795611381530762+                  , 20.98564338684082+                  , 18.01180076599121+                  , 25.297883987426758+                  , 14.819819450378418+                  , 42.39189910888672+                  , 2.9485135078430176+                  , 11.043763160705566+                  , 49.55165100097656+                  , 29.882694244384766+                  , 10.527188301086426+                  , 23.5572452545166+                  , 26.55561637878418+                  , 45.099605560302734+                  , 22.550390243530273+                  , 36.46126174926758+                  , 11.826201438903809+                  , 16.818185806274414+                  , 14.903121948242188+                  , 32.81113815307617+                  , 43.1389045715332+                  , 12.289558410644531+                  , 11.498942375183105+                  , 10.465788841247559+                  , 24.93169593811035 ] ]+; var cf = crotale[0]+; var ca = crotale[1]+; var cd = crotale[2]+; var ps = [-12, -5, 0, 2, 4, 5, 7, 12]+; var n = PinkNoise.ar()+; var t = Dust.kr(3)+; var fs = Select.kr(TIRand.kr(0, 7, t), ps)+; var g = TRand.kr(0, 1, t)+; var fo = TRand.kr(0, 1, t)+; var ds = TRand.kr(2, 7, t)+; var p = TRand.kr(-1, 1, t)+; var s = Decay2.kr(t, 0.06, 0.01) * n * g+; var k = DynKlank.ar(`[cf, ca, cd.reciprocal], s, fs.midiratio, fo, ds)+; Out.ar(0, Pan2.ar(k, p, 1)) }.play
+ src/cut-outs.lhs view
@@ -0,0 +1,27 @@+cut-outs (rd)++> import Sound.SC3.Monadic++> main =+>   let { t = impulse ar 22 0 * (sinOsc kr 0.5 0 + 1)+>       ; x = mouseX kr 0.005 0.12 Exponential 0.1+>       ; y = mouseY kr 0.01 0.52 Exponential 0.1 +>       ; n = do { n1 <- lfNoise0 kr 2+>                ; n2 <- coinGate (0.05 + n1 + y * 0.4 + t * 0.5) (t * 0.5)+>                ; n3 <- tExpRand (mce2 500 900) 1600 t+>                ; return (ringz n2 n3 x) } }+>   in do { s <- fmap sum (sequence (replicate 3 n))+>         ; b <- tRand 0 1 =<< dust kr 8+>         ; audition (mrg [out 0 b, out 0 (clip2 s (in' 1 kr 0) * 0.25)]) }++{ var t = Impulse.ar(22, 0) * (SinOsc.kr(0.5, 0) + 1)+; var x = MouseX.kr(0.005, 0.12, 'exponential', 0.1)+; var y = MouseY.kr(0.01, 0.52, 'exponential', 0.1)+; var n = { var n1 = LFNoise0.kr(2)+          ; var n2 = CoinGate.ar(0.05 + n1 + (y * 0.4) + (t * 0.5), t * 0.5)+          ; var n3 = TExpRand.ar([500, 900], 1600, t)+          ; Ringz.ar(n2, n3, x) }+; var s = Mix.fill(3, n)+; var b = TRand.kr(0, 1, Dust.kr(8))+; Out.kr(0, b)+; Out.ar(0, s.clip2(In.kr(0, 1)) * 0.25) }.play
+ src/cymbalism.lhs view
@@ -0,0 +1,30 @@+cymbalism (jmcc)++> import Sound.SC3.Monadic++> main =+>   let p = replicate 15+>   in do { f1 <- rand 500 2500+>         ; f2 <- rand 0 8000+>         ; let y = do { f <- sequence (p (rand f1 (f1 + f2)))+>                      ; rt <- sequence (p (rand 1 5))+>                      ; return (klankSpec f (p 1) rt) }+>           in do { z <- clone 2 y+>                 ; n <- fmap (* 0.03) (whiteNoise ar)+>                 ; tf <- rand 0.5 3.5+>                 ; let { t = impulse ar tf 0+>                       ; s = decay t 0.004 * n+>                       ; k = klank s 1 0 1 (mceTranspose z) }+>                   in audition (out 0 k) } }++{ var p = 15+; var f1 = Rand.new(500, 2500)+; var f2 = Rand.new(0, 8000)+; var y = { var f = Array.fill(p, { f1 + Rand.new(0, f2) } )+          ; var rt = Array.fill(p, { 1 + Rand.new(0, 4) })+          ; `[f, nil, rt] }+; var z = Array.fill(2, y)+; var t = Impulse.ar(Rand.new(0, 3) + 0.5, 0)+; var n = WhiteNoise.ar() * 0.03+; var s = Decay.ar(t, 0.004) * n+; Out.ar(0, Klank.ar(z, s)) }.play
+ src/deep-sea.lhs view
@@ -0,0 +1,37 @@+deep sea (jrhb)++> import Sound.SC3.ID++> main =+>   let { range s l r = let m = (r - l) * 0.5 in mulAdd s m (m + l)+>       ; amp = 1+>       ; pan = 0+>       ; variation = 0.9+>       ; n = rand 'α' 7 46+>       ; dt1 = 25.0 + rand 'β' (-1.7) 1.7+>       ; dt2 = (dt1 + lfNoise2 'γ' kr 2) * variation * 0.001+>       ; f = 901 + rand 'δ' 0 65+>       ; t = impulse ar (recip dt2) 0 * 100+>       ; count = pulseCount t 0+>       ; mul = count <* n+>       ; u1 = bpf (mul * t) f 1 * 0.1+>       ; f2 = f * ((count `modE` range (lfNoise1 'ε' kr 1) 2 20) + 1)+>       ; u2 = bpf u1 f2 1 * 0.2 }+>   in audition (mrg [ detectSilence u2 0.0001 0.2 RemoveSynth+>                    , out 0 (pan2 u2 pan (amp * 10)) ])++{ var amp = 1+; var pan = 0+; var variation = 0.9+; var n = Rand.new(7, 46)+; var dt1 = 25.0 + Rand.new(-1.7, 1.7)+; var dt2 = (dt1 + LFNoise2.kr(2)) * variation * 0.001+; var freq = 901 + Rand.new(0, 65)+; var t = Impulse.ar(dt2.reciprocal, 0, 100)+; var count = PulseCount.ar(t, 0)+; var mul = count < n+; var u1 = BPF.ar(mul * t, freq, 1) * 0.1+; var freq2 = freq * ((count % LFNoise1.kr(1).range(2, 20)) + 1)+; var u2 = BPF.ar(u1, freq2, 1) * 0.2+; DetectSilence.ar(u2, 0.0001, 0.2, 2)+; Out.ar(0, Pan2.ar(u2, pan, amp * 10)) }.play
+ src/default.lhs view
@@ -0,0 +1,36 @@+default (jmcc)++> import Sound.SC3.Monadic+> import Sound.OpenSoundControl+> import System.Random++> main =+>   let { def = do { r0 <- rand (-0.4) 0.0+>                  ; r1 <- rand 0.0 0.4+>                  ; r2 <- rand 4000 5000+>                  ; r3 <- rand 2500 3200+>                  ; let { f = control KR "freq" 440+>                        ; a = control KR "amp" 0.1+>                        ; p = control KR "pan" 0+>                        ; g = control KR "gate" 1+>                        ; e = linen g 0.01 (a * 0.7) 0.3 RemoveSynth+>                        ; f3 = mce [f, f + r0, f + r1]+>                        ; l = xLine KR r2 r3 1 DoNothing+>                        ; z = lpf (mix (varSaw AR f3 0 0.3)) l * e }+>                    in return (pan2 z p 1) }+>       ; rrand lr = getStdRandom (randomR lr)+>       ; tone fd nid = do { pan <- rrand (-1, 1)+>                          ; amp <- rrand (0.1, 0.3)+>                          ; indx <- rrand (0, 7)+>                          ; let note = [60, 62, 64, 65, 67, 69, 71, 72] !! indx+>                            in send fd (s_new "default" nid AddToTail 1+>                                        [("freq", midiCPS note)+>                                        ,("pan", pan)+>                                        ,("amp", amp)])+>                          ; pauseThread 0.075+>                          ; send fd (n_set nid [("gate", 0)])+>                          ; pauseThread 0.075 } }+>   in withSC3 (\fd -> do { u <- def+>                         ; async fd (d_recv (synthdef "default" (out 0 u)))+>                         ; reset fd+>                         ; mapM_ (tone fd) [1024..1036] })
+ src/demanding-studies.lhs view
@@ -0,0 +1,26 @@+demanding studies (jmcc)++> import Sound.SC3.Monadic++> main =+>   do { s1 <- drand dinf (mce [72, 75, 79, 82])+>      ; s2 <- drand 1 (mce [82, 84, 86])+>      ; s3 <- dseq dinf (mce [72, 75, 79, s2])+>      ; let { x = mouseX kr 5 13 Linear 0.2+>            ; tr = impulse kr x 0+>            ; f = demand tr 0 (mce [midiCPS (s1 - 12), midiCPS s3])+>            ; o1 = sinOsc ar (f + mce2 0 0.7) 0+>            ; o2 = saw ar (f + mce2 0 0.7) * 0.3+>            ; o3 = cubed (distort (log (distort (o1 + o2)))) }+>        in audition (out 0 (o3 * 0.1)) }++{ var s1 = Drand.new([72, 75, 79, 82], inf)+; var s2 = Drand.new([82, 84, 86], 1)+; var s3 = Dseq.new([72, 75, 79, s2], inf)+; var x = MouseX.kr(5, 13, 'linear', 0.2)+; var tr = Impulse.kr(x, 0)+; var f = Demand.kr(tr, 0, [(s1 - 12).midicps, s3.midicps])+; var o1 = SinOsc.ar(f + [0, 0.7], 0)+; var o2 = Saw.ar(f + [0, 0.7]) * 0.3+; var o3 = (o1 + o2).distort.log.distort.cubed+; Out.ar(0, o3 * 0.1) }.play
+ src/dial-history.lhs view
@@ -0,0 +1,52 @@+dial history (jrhb)++> import Data.List+> import Sound.SC3.Monadic++> main =+>   let { mfv = [[697, 770, 852, 941], [1209, 1336, 1477, 1633]]+>       ; numbers = [[3, 1]] ++ [[a, b] | a <- [0..2], b <- [0..2]]+>       ; range s l r = linLin s 0 1 l r+>       ; mce_r = mce . map mce }+>   in do { n <- dwhite dinf 7 12+>         ; w <- dwhite 1 2 7+>         ; b <- dbrown n 0.1 0.2 0.01+>         ; rate <- dseq dinf (mce2 w b)+>         ; q <- dseq dinf (mce [1..10])+>         ; g1 <- grayNoise ar+>         ; g2 <- grayNoise ar+>         ; d <- lfdNoise3 kr 0.5+>         ; let { tr = trig (tDuty kr rate 0 DoNothing q 1) 0.09+>               ; pat = latch tr tr+>               ; x = mouseX kr 0 1 Linear 0.2+>               ; h = hasher (pat * x)+>               ; which = trunc (range h 0 (constant (length numbers))) 1+>               ; both = select which (mce_r numbers)+>               ; dial = select both (mce_r (transpose mfv))+>               ; sig = sinOsc ar dial 0 * 0.05 * tr+>               ; dsig = delayN sig 0.2 (range d 0 0.01)+>               ; hiss = g1 * 0.01 + hpf (g2 * 0.02) 3000 }+>           in audition (out 0 (dsig + hiss)) }++{ var mfv = [[697, 770, 852, 941], [1209, 1336, 1477, 1633]]+; var numbers = [[3, 1]] ++ {: [a, b], a <- (0..2), b <- (0..2) }.all+; var n = Dwhite.new(7, 12, inf)+; var w = Dwhite.new(2, 7, 1)+; var b = Dbrown.new(0.1, 0.2, 0.01, n)+; var rate = Dseq.new([w, b], inf)+; var q = Dseq.new((1..10), inf)+; var trig = Trig.kr(TDuty.kr(rate, 0, q), 0.09)+; var pat = Latch.kr(trig, trig)+; var x = MouseX.kr(0, 1, 'linear', 0.2)+; var h = Hasher.kr(pat * x)+; var which = h.range(0, numbers.size).trunc.(1)+; var both = Select.kr(which, numbers)+; var dial = Select.kr(both, mfv.flop)+; var sig = SinOsc.ar(dial, 0) * 0.05 * trig+; var d = LFDNoise3.kr(0.5)+; var dsig = DelayC.ar(sig, 0.2, d.range(0, 0.01))+; var g1 = GrayNoise.ar+; var g2 = GrayNoise.ar+; var z = Silent.ar(1)+; var hiss = g1 * 0.01 + HPF.ar(g2 * 0.02, 3000)+; Out.ar(0, [z, dsig + hiss]) }.play
+ src/diffraction.lhs view
@@ -0,0 +1,42 @@+diffraction (rd)++> import Control.Monad+> import Sound.SC3.Monadic++> main =+>   let { p = let { x = mouseX kr 0.001 0.02 Exponential 0.1+>                 ; y = mouseY kr 120 400 Exponential 0.1 }+>             in do { f <- fmap (* mce2 32 64) (lfNoise0 kr 4)+>                   ; w <- fmap (* x) (lfNoise0 kr 32)+>                   ; z <- fmap (* 0.1) (lfNoise0 kr 2)+>                   ; m <- lfNoise0 kr 6+>                   ; let s = pulse ar f w+>                     in return (resonz s (y + z) (m * 0.4 + 0.8) * 0.5) }+>       ; q = do { n <- lfNoise0 kr 128+>                ; s <- p+>                ; return (combN s 0.2 (n * 0.1 + 0.1) 3) }+>       ; r = let { x = mouseX kr 0.75 1.25 Exponential 0.1+>                 ; y = mouseY kr 0.25 1 Exponential 0.1+>                 ; f _ = do { fr <- fmap (* x) (rand 50 59)+>                            ; am <- fmap (* y) (rand 0.04 0.16)+>                            ; return (sinOsc ar fr 0 * am) } }+>             in liftM2 mce2 (mixFillM 16 f) (mixFillM 12 f) }+>   in audition . (out 0) . sum =<< sequence [p, q, r]++{ var x = MouseX.kr(0.001, 0.02, 'exponential', 0.1)+; var y = MouseY.kr(120, 400, 'exponential', 0.1)+; var p = { var f = LFNoise0.kr(4) * [32, 64]+	      ; var w = LFNoise0.kr(32) * x+	      ; var z = LFNoise0.kr(2) * 0.1+          ; var m = LFNoise0.kr(6)+	      ; var s = Pulse.ar(f, w)+          ; Resonz.ar(s, y + z, (m * 0.4) + 0.8) * 0.5 }+; var q = { var n = LFNoise0.kr(128)+	      ; CombN.ar(p.value, 0.2, (n * 0.1) + 0.1, 3) }+; var r = { var x1 = MouseX.kr(0.75, 1.25, 'exponential', 0.1)+          ; var y1 = MouseY.kr(0.25, 1, 'exponential', 0.1)+	      ; var f = { var fr = Rand(50, 59) * x1+	                ; var am = Rand(0.04, 0.16) * y1+                    ; SinOsc.ar(fr, 0) * am }+          ; [Mix.fill(16, f), Mix.fill(12, f)] }+; Out.ar(0, p.value + q.value + r.value) }.play
+ src/discretion.lhs view
@@ -0,0 +1,15 @@+discretion (rd)++> import Sound.SC3.Monadic++> main =+>   let { mkls bp t = envGen kr 1 1 0 1 RemoveSynth (envCoord bp t 1 EnvLin)+>       ; part = do { f1 <- clone 2 (rand 50 55)+>                   ; f2 <- clone 2 (rand 50 65)+>                   ; f3 <- clone 2 (rand 50 55)+>                   ; a <- clone 2 (rand 0.01 0.035)+>                   ; let { t = 21+>                         ; f_ = mkls [(0, f1), (0.33, f2), (1, f3)] t+>                         ; a_ = mkls [(0, 0), (0.33, a), (1, 0)] t }+>                     in return (saw ar f_ * a_) } }+>   in audition . out 0 . mix =<< clone 8 part
+ src/drummer.lhs view
@@ -0,0 +1,24 @@+drummer (thor magnusson)++> import Sound.SC3.ID++> main =+>   let { n = whiteNoise 'α' AR+>       ; tempo = 4+>       ; tr = impulse AR tempo 0+>       ; tr_2 = pulseDivider tr 4 2+>       ; tr_4 = pulseDivider tr 4 0+>       ; snare = n * decay2 tr_2 0.005 0.5+>       ; bass = sinOsc AR 60 0 * decay2 tr_4 0.005 0.5+>       ; hihat = hpf n 10000 * decay2 tr 0.005 0.5 }+>   in audition (out 0 (pan2 (snare + bass + hihat) 0 0.4))++{ var tempo = 4+; var n = WhiteNoise.ar()+; var tr = Impulse.ar(tempo, 0)+; var tr_2 = PulseDivider.ar(tr, 4, 2)+; var tr_4 = PulseDivider.ar(tr, 4, 0)+; var snare = n * Decay2.ar(tr_2, 0.005, 0.5)+; var bass = SinOsc.ar(60, 0) * Decay2.ar(tr_4, 0.005, 0.5)+; var hihat = HPF.ar(n, 10000) * Decay2.ar(tr, 0.005, 0.5)+; Out.ar(0, Pan2.ar(snare + bass + hihat, 0, 0.4)) }.play
+ src/e-lamell.lhs view
@@ -0,0 +1,54 @@+e-lamell (rd)++> import Control.Monad+> import Sound.OpenSoundControl+> import Sound.SC3.Monadic+> import System.Random++> main =+>   let { now = NTPi 1+>       ; rrand l r = getStdRandom (randomR (l, r))+>       ; exp_rrand a b = do { n <- rrand 0 1+>                            ; let r = b / a +>                              in return ((r ** n) * a) }+>       ; choose l = return . (l !!) =<< rrand 0 (length l - 1)+>       ; sendSynth fd n u = async fd (d_recv (synthdef n u))+>       ; e_lamell = let { ctl s v = control kr s v+>                        ; f = ctl "f" 440+>                        ; n = ctl "n" 12+>                        ; d = ctl "d" 0.1+>                        ; l = ctl "l" 0+>                        ; a = ctl "a" 1 }+>                    in do { t <- tChoose 1 (mce2 1 32)+>                          ; let { h = line ar n t d DoNothing+>                                ; s = blip ar f h+>                                ; e_d = envPerc 0.005 d+>                                ; e = envGen ar 1 a 0 1 RemoveSynth e_d }+>                            in return (out 0 (pan2 s l e)) }+>       ; r_note o p = do { oe <- choose o+>                         ; pe <- choose p+>                         ; return (oe * 12 + pe) }+>       ; l_sel = r_note [2, 3] [0]+>       ; h_sel = r_note [2, 3, 4] [0]+>       ; mk_s_new f n d a l = s_new "blip" (-1) AddToTail 1+>                                    [("f", f)+>                                    ,("n", n)+>                                    ,("d", d)+>                                    ,("a", a)+>                                    ,("l", l)]+>       ; pattern fd = do { p <- do { f <- liftM midiCPS l_sel+>                                   ; n <- rrand 2 36+>                                   ; d <- exp_rrand 0.01 0.4+>                                   ; a <- rrand 0 0.75+>                                   ; l <- rrand (-1) 1+>                                   ; return (mk_s_new f n d a l) }+>                         ; q <- do { f <- liftM midiCPS h_sel+>                                   ; n <- rrand 2 36+>                                   ; d <- exp_rrand 0.01 0.4+>                                   ; a <- choose [0, 0.25, 0.5, 1]+>                                   ; l <- rrand (-1) 1+>                                   ; return (mk_s_new f n d a l) }+>                         ; send fd (Bundle now [p, q]) +>                         ; pauseThread 0.1 } }+>   in withSC3 (\fd -> do { sendSynth fd "blip" =<< e_lamell+>                         ; replicateM_ 64 (pattern fd) })
+ src/eggcrate.lhs view
@@ -0,0 +1,27 @@+eggcrate (rd)++> import Sound.SC3.Monadic++> main =+>   let { cosu = cos . (* pi) +>       ; sinu = sin . (* pi)+>       ; eggcrate u v = cosu u * sinu v+>       ; p = mce [64, 72, 96, 128, 256, 6400, 7200, 8400, 9600] }+>   in do { [x, y] <- sequence (replicate 2 (brownNoise kr))+>         ; t <- dust kr 2.4+>         ; [f0, f1] <- sequence (replicate 2 (tChoose t p))+>         ; let { f = linLin (eggcrate x y) (-1) 1 f0 f1+>               ; a = linLin x (-1) 1 0 0.1 }+>           in audition (out 0 (pan2 (mix (sinOsc ar f 0)) y a)) }++{ var eggcrate = { arg u, v+                 ; (u * pi).cos * (v * pi).sin }+; var p = [64, 72, 96, 128, 256, 6400, 7200, 8400, 9600]+; var x = BrownNoise.kr()+; var y = BrownNoise.kr()+; var t = Dust.kr(2.4)+; var f0 = TChoose.kr(t, p)+; var f1 = TChoose.kr(t, p)+; var f = LinLin.kr(eggcrate.value(x, y), -1, 1, f0, f1)+; var a = LinLin.kr(x, -1, 1, 0, 0.1)+; Out.ar(0, Pan2.ar(Mix.ar(SinOsc.ar(f, 0)), y, a)) }.play
+ src/f-lets.lhs view
@@ -0,0 +1,26 @@+f-lets (rd)++> import Sound.SC3.Monadic++> main =+>   let { f_let t g j n f = +>         let pd = pulseDivider t j 0+>         in do { r0 <- tiRand (mce2 2 1) n pd+>               ; r1 <- tRand 0.01 0.04 pd+>               ; r2 <- tRand 0.05 0.10 pd+>               ; return (formlet pd (f * r0) r1 r2 * g) }+>       ; mk_n t = do { r0 <- tRand 0 1 t+>                     ; r1 <- tRand 0 1 t+>                     ; r2 <- tRand 0 1 t+>                     ; r3 <- tRand 0 1 t+>                     ; r4 <- coinGate 0.2 t+>                     ; sequence+>                       [ f_let t 0.15 2 9 (mce2 200 400)+>                       , f_let t 0.25 2 9 (mce2 (200 + r0) (400 + r1))+>                       , f_let t 0.05 4 5 (mce2 25 50)+>                       , f_let t 0.15 4 5 (mce2 (25 + r2) (50 + r3))+>                       , let lr = fmap (* (latch r4 t))+>                         in lr (f_let t 0.5 1 16 (mce2 300 600)) ] }+>       ; tr = impulse ar 24 0 }+>   in do { n <- lfNoise0 kr 2+>         ; audition . out 0 . (* (n * 0.25 + 0.25)) . sum =<< mk_n tr }
+ src/fbl-fbf.lhs view
@@ -0,0 +1,27 @@+fbl-fbf (rd)++> import Sound.SC3.Monadic++> main =+>   let { fbl l i d g = let { a0 = l + mce i+>                           ; a1 = delayL a0 (maximum d) (mce d) }+>                       in (localOut (a1 * mce g), a1)+>       ; fbf b i d g = let { a0 = inFeedback 1 (mce b) + mce i+>                           ; a1 = delayL a0 (maximum d) (mce d) }+>                       in (offsetOut (mce b) (mce [a1 * mce g]), a1) }+>   in do { withSC3 reset+>         ; n <- brownNoise ar+>         ; let { e = decay (impulse ar 0.3 0) 0.1 * n * 0.2+>               ; c = 4+>               ; e' = replicate c e+>               ; b0 = [24, 26, 28, 30]+>               ; d0 = [0.1, 0.3, 0.5, 0.7]+>               ; g0 = [0.8, 0.6, 0.4, 0.2]+>               ; b1 = [25, 27, 29, 31]+>               ; d1 = [0.2, 0.3, 0.6, 0.7]+>               ; g1 = [0.8, 0.7, 0.4, 0.3]+>               ; (u0, s0) = fbl (localIn c ar) e' d0 g0+>               ; (u1, s1) = fbf b0 e' d0 g0+>               ; (u2, s2) = fbf b1 (mceChannels s1) d1 g1+>               ; o = mce [mix (s0 + s1), mix s2] }+>           in audition (mrg [u0, u1, u2, offsetOut 0 o]) }
+ src/feedr.lhs view
@@ -0,0 +1,23 @@+feedr (rd)+warning: input/output feedback loop++> import Sound.SC3.Monadic++> main =+>   let { delayWr b i = recordBuf b 0 1 0 1 Loop 0 DoNothing i+>       ; tap nc b dt = playBuf nc b 1 0 (dt * (- sampleRate)) Loop DoNothing+>       ; dl = 6+>       ; feedr n = do { t <- sequence (replicate n (rand 0.0 (constant dl)))+>                      ; g <- sequence (replicate n (rand 0.4 1.0))+>                      ; f <- sequence (replicate n (rand 0.9 0.95))+>                      ; let { d = zipWith (\p q -> tap 2 10 p * q) t g+>                            ; x = mouseX kr 0.02 1.0 Exponential 0.1+>                            ; s = clip2 (leakDC (hpf (sum d) 20) 0.995) 1+>                            ; i = soundIn (mce2 0 1)+>                            ; r = i + sum (map (* x) (zipWith (*) d f)) }+>                        in return (mrg [out 0 s, delayWr 10 r]) } }+>   in withSC3 (\fd -> do { nf <- fmap (* dl) (serverSampleRateActual fd)+>                         ; send fd (b_alloc 10 (floor nf) 2)+>                         ; audition =<< feedr 18 })++withSC3 (\fd -> send fd (b_zero 10))
+ src/fm-iter.lhs view
@@ -0,0 +1,17 @@+fm-iter (rd)++> import Sound.SC3.Monadic++> main =+>   let { t0 = impulse ar (recip 0.30) 0+>       ; t1 = tDelay t0 0.15+>       ; t = mce2 t0 t1 }+>   in do { k <- tRand 56 57 t+>         ; i <- tRand 40 480 t+>         ; j <- tRand (-1) 1 t+>         ; let { c = midiCPS k+>               ; m = midiCPS (k + 1 + j)+>               ; s = envPerc 0.01 0.9+>               ; e = envGen ar t 0.1 0 1 RemoveSynth s+>               ; f = sinOsc ar c 0 * i + m }+>           in audition (out 0 (sinOsc ar f 0 * e)) }
+ src/fm-kltr.lhs view
@@ -0,0 +1,49 @@+fm-kltr (rd)++> import Sound.OpenSoundControl+> import Sound.SC3.Monadic+> import System.Random++> main =+>   let { rrand l r = getStdRandom (randomR (l, r))+>       ; gr =+>             do { r1 <- rand 0.975 1.025+>                ; r2 <- rand 0.5 1.5+>                ; r3 <- rand 0.975 1.025+>                ; r4 <- rand 0.75 1.25+>                ; let { o = control ir "out" 0+>                      ; t = control kr "trig" 0 {- unused -}+>                      ; a = control kr "amp" 0.1+>                      ; d = control kr "dur" 0.1+>                      ; f = control kr "freq" 400.0+>                      ; i = control kr "index" 40.0+>                      ; p = control kr "pan" 0.0+>                      ; f2 = control kr "freq2" 600+>                      ; ep = envPerc 0.01 d+>                      ; e = envGen ar 1 a 0 1 RemoveSynth ep+>                      ; so = sinOsc ar (xLine kr f (f * r1) d DoNothing) 0+>                      ; xl = xLine kr f2 (f2 * r3) d DoNothing+>                      ; m = so * line kr i (f * r2) d DoNothing + xl+>                      ; l = line kr p (p * r4) d DoNothing }+>                  in return (out o (pan2 (sinOsc ar m 0) l e)) }+>       ; fm fd f ff a d i =+>           do { r1 <- rrand (-1) 1+>              ; r2 <- rrand (-1) 1+>              ; send fd (s_new "fm" (-1) AddToTail 1+>                               [("freq", midiCPS f)+>                               ,("freq2", midiCPS ff + r1)+>                               ,("amp", a)+>                               ,("dur", d)+>                               ,("index", i)+>                               ,("pan", r2)]) }+>       ; nd fd =+>           do { ff <- rrand 48 96+>              ; a <- rrand 0.1 0.4+>              ; d <- rrand 1.2 7.2+>              ; i <- rrand 240 1480+>              ; t <- rrand 0.15 1.25+>              ; fm fd 53 ff a d i+>              ; pauseThread t } }+>   in withSC3 (\fd -> do { u <- gr+>                         ; async fd (d_recv (synthdef "fm" u))+>                         ; sequence (replicate 32 (nd fd)) })
+ src/forest-sounds.lhs view
@@ -0,0 +1,18 @@+forest sounds (paul jones)++> import Sound.SC3.Monadic++> main =+>   let insects = do { n1 <- brownNoise ar+>                    ; n2 <- lfNoise2 kr 50+>                    ; let o = sinOsc kr (n2 * 50 + 50) 0 * 100 + 2000+>                      in return (bpf n1 o 0.001 * 10) }+>   in audition . (out 0) =<< clone 2 insects++{ var insects = { var n1 = BrownNoise.ar+                ; var n2 = LFNoise2.kr(50)+                ; var o = SinOsc.kr(n2 * 50 + 50, 0) * 100 + 2000+                ; BPF.ar(n1, o, 0.001) * 10 }+; Out.ar(0, Array.fill(2, insects)) }.play++sc-users, 2007-04-06
+ src/fwalk.lhs view
@@ -0,0 +1,28 @@+fwalk (rd)++> import Sound.SC3.Monadic++> main =+>   let { n = [ 40.0, 47.0, 42.0, 40.0, 50.0+>             , 43.0, 35.0, 43.0, 40.0, 47.0+>             , 45.0, 35.0, 43.0, 42.0, 59.0+>             , 48.0, 40.0, 47.0, 52.0, 45.0 ]+>       ; m = [ 40.0, 40.0, 42.0, 47.0, 50.0+>             , 35.0, 43.0, 43.0, 40.0, 45.0+>             , 42.0, 35.0, 48.0, 47.0, 43.0+>             , 40.0, 59.0, 45.0, 47.0, 52.0 ] +>       ; a = map (\b -> b_alloc b 20 1) [0, 1]+>       ; s = map (\(b, d) -> b_setn1 b 0 d) [(0, n), (1, m)]+>       ; fwalk r = do { t <- dust kr 3+>                      ; r1 <- tiRand 0 6 t+>                      ; r2 <- tRand (-0.0001) 0.0001 t+>                      ; let { f = bufRdL 1 kr (mce2 0 1) r1 NoLoop+>                            ; f' = f + r2+>                            ; o1 = blip ar (midiCPS (r + f)) 12+>                            ; o2 = blip ar (midiCPS (r + f')) 12 }+>                        in return ((o1 + o2) * decay2 t 0.3 1.2 * 0.1) } }+>   in withSC3 (\fd -> do { f1 <- fwalk 24+>                         ; f2 <- fwalk 36+>                         ; mapM_ (async fd) a+>                         ; mapM_ (send fd) s+>                         ; play fd (out 0 (f1 + f2)) })
+ src/h-chatter.lhs view
@@ -0,0 +1,45 @@+h-chatter (rd)++> import Control.Monad+> import Sound.SC3.Monadic++> main =+>   let { wrp i l r = linLin i (-1) 1 l r+>       ; mma m a = return . (+ a)  . (* m)+>       ; h0 = do { n <- mma 5 5 =<< lfNoise0 kr 1+>                 ; a <- mma 0.2 1.2 =<< lfNoise2 kr n+>                 ; b <- mma 0.15 0.15 =<< lfNoise2 kr n+>                 ; let { f = 40+>                       ; h = henonN ar (mce2 f (f * 0.5)) a b 0 0 }+>                   in return (saw ar (h * 3200 + 1600) * 0.35) }+>       ; h1 = do { n0 <- lfNoise0 kr 32+>                 ; n1 <- lfNoise0 kr 2+>                 ; let { a = mouseX kr 1.2 1.4 Linear 0.1+>                       ; b = mouseY kr 0.2 0.3 Linear 0.1+>                       ; h = wrp n0 1 32+>                       ; p = wrp n1 2400 3200+>                       ; l = wrp n1 (-0.75) 0.75+>                       ; g = wrp n1 0.55 0.85+>                       ; f = 40+>                       ; o = blip ar (wrp (henonN ar f a b 0 0) p (p * 2)) h }+>                   in return (pan2 o l g * 0.35) } }+>   in audition . out 0 =<< liftM2 (+) h0 h1++{ var h0 = { var n = LFNoise0.kr(1, 5, 5)+           ; var a = LFNoise0.kr(1, 0.2, 1.2)+           ; var b = LFNoise0.kr(1, 0.15, 0.15)+           ; var f = 40+           ; var h = HenonN.ar([f, f * 0.5], a, b, 0, 0)+           ; Saw.ar(h * 3200 + 1600) * 0.35 }+; var h1 = { var n0 = LFNoise0.kr(32)+           ; var n1 = LFNoise0.kr(2)+           ; var a = MouseX.kr(1.2, 1.4, 'linear', 0.1)+           ; var b = MouseY.kr(0.2, 0.3, 'linear', 0.1)+           ; var h = n0.range(1, 32)+           ; var p = n1.range(2400, 3200)+           ; var l = n1.range(-0.75, 0.75)+           ; var g = n1.range(0.55, 0.85)+           ; var f = 40+           ; var o = Blip.ar(HenonN.ar(f, a, b, 0, 0).range(p, p * 2), h)+           ; Pan2.ar(o, l, g) * 0.35 }+; Out.ar(0, h0.value + h1.value) }.play
+ src/half-life.lhs view
@@ -0,0 +1,18 @@+half-life (jrhb)++> import Sound.SC3.Monadic++> main =+>   let { t_half = 3.92+>       ; n_atoms = 1e+5+>       ; n = max 0 (n_atoms - pulseCount (localIn 2 ar) 0) }+>   in do { activity <- dust ar (n * log 2 / t_half)+>         ; audition (mrg [ localOut activity+>                         , out 0 activity ]) }++{ var t_half = 3.92+; var n_atoms = 1e+5+; var n = max(0, n_atoms - PulseCount.ar(LocalIn.ar(2), 0))+; var activity = Dust.ar(n * 2.log / t_half)+; LocalOut.ar(activity)+; Out.ar(0, activity) }.play
+ src/harmonic-swimming.lhs view
@@ -0,0 +1,25 @@+harmonic swimming (jmcc)++> import Sound.SC3.Monadic++> main =+>   let { a = 0.02+>       ; f = 50+>       ; p = 20+>       ; l = line kr 0 (- a) 60 DoNothing +>       ; o h = do { r <- clone 2 (rand 2 8)+>                  ; n <- lfNoise1 kr r+>                  ; let e = max 0 (n * a + l)+>                    in return (fSinOsc ar (f * (h + 1)) 0 * e) } }+>   in audition . out 0 . sum =<< mapM o [0..p]++{ var a = 0.02+; var f = 50+; var p = 20+; var l = Line.kr(0, a.neg, 60, 0)+; var o = { arg h+          ; var r = 6 + [Rand.new(-4, 4), Rand.new(-4, 4)]+          ; var n = LFNoise1.kr(r)+          ; var e = max(0, n * a + l)+          ; FSinOsc.ar(f * (h + 1), 0) * e }+; Out.ar(0, (0..p).collect(o).sum) }.play
+ src/harmonic-tumbling.lhs view
@@ -0,0 +1,23 @@+harmonic tumbling (jmcc)++> import Sound.SC3.Monadic++> main =+>   let { f = 80+>       ; p = 10+>       ; t = xLine kr (mce2 10 11) 0.1 60 DoNothing+>       ; o h = do { n <- dust kr t+>                  ; r <- rand 0 0.5+>                  ; let e = decay2 (n * 0.02) 0.005 r+>                    in return (fSinOsc ar (f * (h + 1)) 0 * e) } }+>   in audition . out 0 . sum =<< mapM o [0..p]++{ var f = 80+; var p = 10+; var t = XLine.kr([10, 11], 0.1, 60, doneAction: 0)+; var o = { arg h+          ; var n = Dust.kr(t)+          ; var r = Rand.new(0, 0.5)+          ; var e = Decay2.kr(n * 0.02, 0.005, r)+          ; FSinOsc.ar(f * (h + 1), 0) * e }+; Out.ar(0, (0..p).collect(o).sum) }.play
+ src/hh-808.lhs view
@@ -0,0 +1,25 @@+hh-808 (ryan at wabdo.com)++> import Sound.SC3++> main =+>   let { time = 250+>       ; freqs = [205.35, 304.41, 369.64, 522.71, 540.54, 812.21]+>       ; pulseEnv = let e = env [1.0, 0.6] [time] [EnvNum (-0.5)] 0 0+>                    in envGen ar 1 1 0 (1/1000) DoNothing e+>       ; s = mix (lfPulse ar (mce (map (* 4.09) freqs)) 0 0.5)+>       ; f = [ \a -> ((a ==* 6.0) * 0.6) + ((a ==* 2.0) * 0.2) + ((a ==* 1.0) * 0.9)+>             , \a -> (a * pulseEnv) + ((mix (lfPulse ar (mce freqs) 0 0.55)) * 0.9)+>             , \a -> rlpf a 7000 0.6+>             , \a -> rhpf a 6800 1.5+>             , \a -> rhpf a 6800 1.5+>             , \a -> rhpf a 1200 1.5+>             , \a -> a + freeVerb a 0.33 0.5 0.5+>             , \a -> let { c = map EnvNum [0, -0.5, 0, -50]+>                         ; e = env [0, 1, 0.4, 0, 0] [2, time, 50, 500] c 0 0 }+>                     in a * envGen ar 1 1 0 (1/1000) RemoveSynth e+>             , \a -> mce [a, delayN a 0.005 0.005] ]+>       ; (>>>) = flip (.) }+>   in audition (out 0 (foldl1 (>>>) f s * 2))++http://www.create.ucsb.edu/pipermail/sc-users/2007-August/036131.html
+ src/implosion.lhs view
@@ -0,0 +1,22 @@+implosion (rd)++> import Sound.SC3.Monadic++> main =+>   let { mkls bp t = let e = envCoord bp t 1 EnvLin+>                     in envGen kr 1 1 0 1 RemoveSynth e+>       ; mkrmp l r t = mkls [(0, l), (1, r)] t+>       ; wrp i l r = linLin i (-1) 1 l r+>       ; pmr_n rt l0 l1 r0 r1 d = let { le = mkrmp l0 r0 d+>                                      ; re = mkrmp l1 r1 d }+>                                  in do { n <- whiteNoise rt+>                                        ; return (wrp n le re) } }+>   in do { n0 <- rand (-1) 0+>         ; n1 <- rand 0 1+>         ; d  <- rand 7.5 13.5+>         ; f0 <- rand 10990 16220+>         ; f1 <- rand  9440 19550+>         ; f <- pmr_n ar 440 f0 f1 f1 d+>         ; l <- pmr_n kr n0 n1 0 0 d+>         ; a <- pmr_n kr 0.1 0.6 0 0 d+>         ; audition (out 0 (pan2 (saw ar f) l a)) }
+ src/insects.lhs view
@@ -0,0 +1,15 @@+insects (sam pluta)++> import Sound.SC3.Monadic++> main =+>   let insect = do { r1 <- rand 2000 3000+>                   ; r2 <- rand 0.05 0.1+>                   ; n1 <- lfNoise2 KR (r2 * 50 + 50)+>                   ; r4 <- rand 1 10+>                   ; r5 <- rand 0.05 0.1+>                   ; n2 <- lfNoise2 KR r5+>                   ; let { a = sinOsc KR r4 0 * 0.5 + 0.5+>                         ; o = sinOsc AR (r1 + n1) r2 * 0.005 * a }+>                     in return (pan2 o n2 1) }+>   in audition . (out 0) . sum =<< sequence (replicate 60 insect)
+ src/k-ppr.lhs view
@@ -0,0 +1,36 @@+k-ppr (rd)++> import Control.Monad+> import Sound.SC3.Monadic++> main =+>   let { wrp i l r = linLin i (-1) 1 l r+>       ; x = mouseX kr 0.05 0.35 Linear 0.1+>       ; y = mouseY kr 0.15 0.75 Linear 0.1+>       ; ti = lfTri kr x 0+>       ; tf = wrp ti 100 200+>       ; t = impulse ar tf 0+>       ; stream lf rf ld rd g = +>           do { r1 <- rand 9 18+>              ; let t' = pulseDivider t r1 0+>                in do { r2 <- tRand lf (wrp ti lf rf) t'+>                      ; r3 <- tRand ld rd t'+>                      ; return (ringz (decay2 t' 0.01 0.5) r2 (r3 * y) * g) } } +>       ; s1 = stream 3140 6240 0.050 0.005 0.15 +>       ; s2 = stream 0400 9000 0.005 0.005 0.15 }+>   in audition . out 0 =<< liftM2 (+) (clone 2 s1) (clone 2 s2)++{ var x = MouseX.kr(0.05, 0.35, 'linear', 0.1)+; var y = MouseY.kr(0.15, 0.75, 'linear', 0.1)+; var ti = LFTri.kr(x, 0)+; var tf = ti.range(100, 200)+; var t = Impulse.ar(tf, 0)+; var stream = { arg lf, rf, ld, rd, g+               ; { var r1 = Rand.new(9, 18)+                 ; var t_ = PulseDivider.ar(t, r1, 0)+                 ; var r2 = TRand.ar(lf, ti.range(lf, rf), t_)+                 ; var r3 = TRand.ar(ld, rd, t_)+                 ; Ringz.ar(Decay2.ar(t_, 0.01, 0.5), r2, r3 * y) * g } }+; var s1 = stream.value(3140, 6240, 0.050, 0.005, 0.15)+; var s2 = stream.value(0400, 9000, 0.005, 0.005, 0.15)+; Out.ar(0, Array.fill(2, s1) + Array.fill(2, s2)) }.play
+ src/karplus-strong.lhs view
@@ -0,0 +1,40 @@+karplus strong (alex mclean)++> import Sound.SC3.Monadic++> main =+>   let { aA = ( "aA" +>              , [800, 1150, 2800, 3500, 4950]+>              , [0, -4  , -20, -36 , -60]+>              , [80, 90,  120, 130, 140] )+>       ; aU = ( "aU" +>              , [325, 700, 2530, 3500, 4950]+>              , [0, -12 , -30, -40, -64]+>              , [50, 60,  170, 180, 200] )+>       ; cs (_, c1, c2, c3) = c1 ++ c2 ++ c3+>       ; vf i s = let { f = in' 5 kr i+>                      ; a = in' 5 kr (i + 5)+>                      ; b = in' 5 kr (i + 10) }+>                  in mix (resonz s f (b / f) * dbAmp a)+>       ; ks n d = let { x = mouseX kr 0 0.01 Linear 0.1 {- delay -}+>                      ; y = mouseY kr 0.85 1 Linear 0.1 {- blend / gain -}+>                      ; ugenIf a b c = (a * b) + ((1 - a) * c)+>                      ; n0 = (n / 2) + 0.5+>                      ; probSwitch i prob = ugenIf (n0 >* prob) i (negate i)+>                      ; laggedDelay = lag x 0.01+>                      ; o = sinOsc ar 200 0+>                      ; a0 = decay d 0.025 * o+>                      ; a1 = localIn 1 ar + (a0 * (y - 0.25))+>                      ; a2 = delayN a1 0.01 laggedDelay+>                      ; a3 = delay1 a2+>                      ; a4 = (a2 + a3) / 2.0+>                      ; a5 = probSwitch a4 y+>                      ; a6 = vf (toggleFF d * 15) a5+>                      ; a7 = a6 * 1.5 }+>                 in mrg [localOut (a5 * 0.99), out 0 (mce [a7, a7])] }+>   in withSC3 (\fd -> do { send fd (c_setn [(0,cs aA), (15, cs aU)])+>                         ; n <- whiteNoise ar+>                         ; d <- dust kr 4+>                         ; play fd (ks n d) })++Variant on http://doc.gold.ac.uk/~ma503am/alex/vocable-source-released/
+ src/klink.lhs view
@@ -0,0 +1,28 @@+klink (rd)++> import Sound.SC3.Monadic++> main =+>   do { n1 <- lfNoise0 kr (mce2 0.5 1.5)+>      ; let { o = sinOsc kr n1 0+>            ; f = mce2 2 3+>            ; a = abs (slope o) * f+>            ; t = impulse ar a 0+>            ; i = decay2 t 0.01 0.1+>            ; x = mouseX kr 960 3620 Exponential 0.2+>            ; y = mouseY kr 0.5 2.0 Linear 0.2 }+>        in do { n2 <- tRand x 3940 t+>              ; n3 <- tRand 0.005 0.275 t+>              ; audition (out 0 (ringz i n2 (n3 * y))) } }++{ var n1 = LFNoise0.kr([0.5, 1.5])+; var o = SinOsc.kr(n1, 0)+; var f = [2, 3]+; var a = Slope.kr(o).abs * f+; var t = Impulse.ar(a, 0)+; var i = Decay2.ar(t, 0.01, 0.1)+; var x = MouseX.kr(960, 3620, 'exponential', 0.2)+; var y = MouseY.kr(0.5, 2.0, 'linear', 0.2)+; var n2 = TRand.ar(x, 3940, t)+; var n3 = TRand.ar(0.005, 0.275, t)+; Out.ar(0, Ringz.ar(i, n2, n3 * y)) }.play
+ src/lf-pulses.lhs view
@@ -0,0 +1,18 @@+lf pulses (rd)++> import Sound.SC3.Monadic++> main =+>   do { n0 <- lfNoise0 AR (mce2 20 40)+>      ; n1 <- lfNoise0 AR (mce2 5 10)+>      ; let { x = mouseX KR 0.012 0.19 Exponential 0.1+>            ; f = formlet (blip AR 10 12) (n0 * 43 + 700) 0.005 x +>            ; o = sinOsc AR 40 0 * n1 }+>        in audition (out 0 (clip2 (leakDC (f + o) 0.995) 0.75)) }++{ var n0 = LFNoise0.ar([20, 40])+; var n1 = LFNoise0.ar([5, 10])+; var x = MouseX.kr(0.012, 0.19, 'exponential', 0.1)+; var f = Formlet.ar(Blip.ar(10, 12), n0 * 43 + 700, 0.005, x)+; var o = SinOsc.ar(40, 0) * n1+; Out.ar(0, LeakDC.ar(f + o, 0.995).clip2(0.75)) }.play
+ src/lfo-modulation.lhs view
@@ -0,0 +1,14 @@+lfo modulation (jmcc)++> import Sound.SC3++> main =+>   let { o = fSinOsc kr 0.05 0 * 80 + 160+>       ; p = fSinOsc kr (mce2 0.6 0.7) 0 * 3600 + 4000+>       ; s = rlpf (lfPulse ar o 0 0.4 * 0.05) p 0.2 }+>   in audition (out 0 (combL s 0.3 (mce2 0.2 0.25) 2))++{ var o = FSinOsc.kr(0.05, 0, 80, 160)+; var p = FSinOsc.kr([0.6, 0.7], 0, 3600, 4000)+; var s = RLPF.ar(LFPulse.ar(o, 0, 0.4, 0.05), p, 0.2)+; Out.ar(0, CombL.ar(s, 0.3, [0.2, 0.25], 2)) }.play
+ src/lg-timed.lhs view
@@ -0,0 +1,39 @@+lg-timed (rd)++> import Sound.SC3.Monadic++> main =+>   let { timed r y p =+>         do { d0 <- dser r p+>            ; d1 <- dcons 0 d0+>            ; d2 <- dser r y+>            ; let t = tDuty AR d1 0 RemoveSynth d2 1+>              in return (latch t t) }+>       ; lg u = return (lag u 0.03)+>       ; n = mce [52, 76, 66, 67, 68, 69]+>       ; a = mce [0.35, 0.15, 0.04, 0.05, 0.16, 0.07]+>       ; d = mce [0.1, 0.5, 0.09, 0.08, 0.07, 0.3]+>       ; x = mouseX KR 0.5 1.25 Linear 0.2 }+>   in do { tn <- lg =<< timed dinf n (d * x)+>         ; ta <- lg =<< timed dinf a (d * x)+>         ; audition (out 0 (sinOsc AR (midiCPS tn) 0 * ta)) }++{ var dcons = { arg x, xs+              ; var i = Dseq.new([0, 1], 1)+              ; var a = Dseq.new([x, xs], 1)+              ; Dswitch.new(a, i) }+; var timed = { arg r, y, p+              ; var d0 = Dser.new(p, r)+              ; var d1 = dcons.value(0, d0)+              ; var d2 = Dser.new(y, r)+              ; var t = TDuty.ar(d1, 0, d2, 2, 1)+              ; Latch.ar(t, t) }+; var lg = { arg u+           ; Lag.ar(u, 0.03) }+; var n = [52, 76, 66, 67, 68, 69]+; var a = [0.35, 0.15, 0.04, 0.05, 0.16, 0.07]+; var d = [0.1, 0.5, 0.09, 0.08, 0.07, 0.3]+; var x = MouseX.kr(0.5, 1.25, 'linear', 0.2)+; var tn = lg.value(timed.value(inf, n, d * x))+; var ta = lg.value(timed.value(inf, a, d * x))+; Out.ar(0, SinOsc.ar(tn.midicps, 0) * ta) }.play
+ src/lin-sosc.lhs view
@@ -0,0 +1,58 @@+lin-sosc (rd)++> import Control.Concurrent+> import Control.Monad+> import Sound.OpenSoundControl+> import Sound.SC3+> import System.Random++> main =+>   let { n = 1024+>       ; x = mouseX KR 0.001 1.0 Linear 0.1+>       ; tblM b = playBuf 1 b (x * bufRateScale KR b) 0 0 Loop DoNothing+>       ; tblC b c = playBuf 1 b (in' 1 KR c * bufRateScale KR b) 0 0 Loop DoNothing+>       ; o = sinOsc AR (tblM 0) 0 * tblM 1 +>       ; co = clip2 (pan2 o (tblC 1 0) 0.025) 0.25+>       ; rrand (a, b) = getStdRandom (randomR (a,b))+>       ; choose l = fmap (l !!) (rrand (0, length l - 1))+>       ; iota 0 _ _ = []+>       ; iota n l s = l : iota (n - 1) (l + s) s+>       ; geom 0 _ _ = []+>       ; geom n i f = i : geom (n - 1) (i * f) f+>       ; lineTo n l r = iota n l ((r - l) / n)+>       ; xlineTo n l r = geom n l ((r / l) ** (1.0 / n))+>       ; twoPi = pi * 2.0+>       ; srng l r e = let m = (l - r ) / 2+>                      in m + l + (e * m) +>       ; freq = [ lineTo n 440.0 444.0+>                , lineTo n 40.0 16000.0+>                , xlineTo n 40.0 16000.0+>                , map (srng 20 21000 . sin) (lineTo n 0.0 twoPi)+>                , map (srng 20 12000 . cos) (lineTo n 0.0 twoPi)+>                , map (srng 20 22000 . tan) (lineTo n 0.0 twoPi)+>                , map (srng 20 90 . tan) (lineTo n 0.0 twoPi) ]+>       ; ampl = [ lineTo n 0.1 1.0+>                , lineTo n 1.0 0.1+>                , lineTo n 0.5 0.01+>                , lineTo n 0.01 0.5+>                , xlineTo n 1.0 0.1+>                , xlineTo n 0.1 1.0+>                , map sin (lineTo n 0.0 twoPi)+>                , map cos (lineTo n 0.0 twoPi)+>                , map (* 0.001) (map tan (lineTo n 0 twoPi)) ]+>       ; sloc = [ 0.005, 0.0075, 0.01, 0.025, 0.05, 0.075+>                , 0.1, 0.25, 0.5, 0.75+>                , 0.8, 0.85, 1.0, 1.005 ]+>       ; paus = [0.01, 0.05, 0.1, 0.15, 0.25, 0.5, 0.75]+>       ; update fd = do { f <- choose freq+>                        ; a <- choose ampl+>                        ; s <- choose sloc+>                        ; p <- choose paus+>                        ; send fd (b_setn 0 [(0, f)])+>                        ; send fd (b_setn 1 [(0, a)])+>                        ; send fd (c_set [(0, s)])+>                        ; pauseThread p } }+>   in do { withSC3 (\fd -> do { async fd (b_alloc 0 (floor n) 1)+>                              ; async fd (b_alloc 1 (floor n) 1)+>                              ; play fd (out 0 co) })+>         ; forkIO (withSC3 (\fd -> replicateM_ 128 (update fd))) }
+ src/lucier.hs view
@@ -0,0 +1,93 @@+{-+Alvin Lucier, "Music on a Long Thin Wire, Simulated"+Chandrasekhar Ramakrishnan+http://www.listarc.bham.ac.uk/lists/sc-users/msg47539.html+http://www.listarc.bham.ac.uk/lists/sc-users/msg47540.html+-}++import Sound.SC3.ID++lucier_wire :: UGen -> IO ()+lucier_wire freq =+    let block_size = recip controlRate+        mk_dt f = recip f - block_size+	string_delay = mk_dt freq+	pk1_pos = 0.1 -- pickup one position+	src_pos = 0.3 -- source position+	pk2_pos = 0.9 -- pickup two postion+	max_delay = 1.0 -- maximum delay time (corresponds to a length = c * s)+	mk_delay i r = lpz1 (delayC i max_delay (r * string_delay))+	mk_allpass i r dt = lpz1 (allpassC i max_delay (r * string_delay) dt)+	drv = localIn 1 AR -- driver (source + data stored in the string)+	pk1_R =+            let i = drv+                r = src_pos - pk1_pos+            in mk_delay i r+	pk1_L =+            let i = pk1_R * negate 1+                r = pk1_pos * 2+                dt = rand 'α' 0.001 0.11+            in mk_allpass i r dt+	pk2_L =+            let i = pk1_L+                r = pk2_pos - pk1_pos+            in mk_delay i r * 0.99+	stringL =+            let i = pk2_L+                r = 1.0 - pk2_pos+            in mk_delay i r+	pk2_R =+            let i = stringL * negate 1+                r = 1.0 - pk2_pos+                dt = 2 + rand 'β' 0.001 0.11+            in mk_allpass i r dt * 0.99+	stringR =+            let i = pk2_R+                r = pk2_pos - src_pos+            in mk_delay i r+	source =+            let s = sinOsc AR 220 0 * 0.01+                p = pulse AR (60 + amplitude KR drv 0.01 0.01 * 11) 0.5 * 0.1+                f = rlpf (s + p) 320 0.05+                e = 1.0 - min (amplitude KR drv 0.01 0.01) 1.0+	    in normalizer f 0.7 0.01 * e+	l_out = localOut (source * 0.2 + stringR)+	outL = pk1_L + pk1_R+	outR = pk2_L + pk2_R+    in audition (out 0 (mrg [mce2 outL outR, drv, source, l_out]))++main = lucier_wire 60++{-+lucier_wire 60++{ var blocksize = ControlRate.ir.reciprocal+; var mk_dt = { |f| f.reciprocal - blocksize }+; var string_dt = mk_dt.(60)+; var c = 425+; var len = 40+; var pk1_p = 0.1+; var src_p = 0.3+; var pk2_p = 0.9+; var max_dt = 1+; var mk_dl = { arg i, r+                 ; LPZ1.ar(DelayC.ar(i, max_dt, r * string_dt)) }+; var mk_ap = { arg i, r, dt+	          ; LPZ1.ar(AllpassC.ar(i, max_dt, r * string_dt, dt)) }+; var drv = LocalIn.ar(1)+; var r = { Rand(0.001, 0.11) }+; var pk1_R = mk_dl.(drv, src_p - pk1_p, 2 + r.())+; var pk1_L = mk_ap.(pk1_R * -1, pk1_p * 2, r.())+; var pk2_L = mk_dl.(pk1_L, pk2_p - pk1_p, r.()) * 0.99+; var strL = mk_dl.(pk2_L, 1 - pk2_p, r.())+; var pk2_R = mk_ap.(strL * -1, 1 - pk2_p, 2 + r.()) * 0.99+; var strR = mk_dl.(pk2_R, pk2_p - src_p, 2 + r.())+; var src = { var a = Amplitude.kr(drv, mul: 11)+            ; p = Pulse.ar(60 + a, mul: 0.1)+            ; RLPF.ar((SinOsc.ar(220, 0) * 0.01) + p, 320, 0.05) }+; var src_n = { var a = Amplitude.kr(drv).min(1.0)+              ; Normalizer.ar(src, 0.7) * (1.0 - a) }+; LocalOut.ar(src * 0.2 + strR)+; [pk1_L + pk1_R, pk2_L + pk2_R, drv, src] }.play++-}
+ src/modal-space.lhs view
@@ -0,0 +1,37 @@+modal space (jmcc)++> import Sound.SC3.Monadic++> main =+>   let { b = 0+>       ; p = [0, 2, 3.2, 5, 7, 9, 10] +>       ; x = mouseX kr 0 15 Linear 0.1+>       ; k = degreeToKey 0 x 12+>       ; c n r = let { o = sinOsc ar (midiCPS (r + k + n * 0.04)) 0 * 0.1+>                     ; t = lfPulse ar (midiCPS (mce2 48 55)) 0.15 0.5+>                     ; f = midiCPS (sinOsc kr 0.1 0 * 10 + r)+>                     ; d = rlpf t f 0.1 * 0.1+>                     ; m = o + d }+>                 in combN m 0.31 0.31 2 + m }+>   in withSC3 (\fd -> do { async fd (b_alloc b (length p) 1)+>                         ; send fd (b_setn1 b 0 p)+>                         ; n <- clone 2 (lfNoise1 kr 3)+>                         ; play fd (out 0 ((c n 48 + c n 72) * 0.25)) })++{ var s = Server.default+; var b = 0+; var p = FloatArray[0, 2, 3.2, 5, 7, 9, 10]+; var x = MouseX.kr(0, 15, 'linear', 0.1)+; var k = DegreeToKey.kr(b, x, 12)+; var c = { arg n, r+          ; var o = SinOsc.ar((r + k + (n * 0.04)).midicps, 0) * 0.1+          ; var t = LFPulse.ar([48, 55].midicps, 0.15, 0.5)+          ; var f = (SinOsc.kr(0.1, 0) * 10 + r).midicps+          ; var d = RLPF.ar(t, f, 0.1) * 0.1+          ; var m = o + d+          ; CombN.ar(m, 0.31, 0.31, 2) + m }+; var n = LFNoise1.kr([3, 3])+; var b_setn1 = { arg b, i, p+                ; ["/b_setn", b, i, p.size] ++ p }+; s.sendMsg("/b_alloc", b, p.size, 1, b_setn1.value(b, 0, p).asRawOSC)+; Out.ar(0, (c.value(n, 48) + c.value(n, 72)) * 0.25) }.play
+ src/moto-rev.lhs view
@@ -0,0 +1,12 @@+moto rev (jmcc)++> import Sound.SC3++> main =+>   let { f = sinOsc kr 0.2 0 * 10 + 21+>       ; s = lfPulse ar f (mce2 0 0.1) 0.1 }+>   in audition (out 0 (clip2 (rlpf s 100 0.1) 0.4))++{ var f = SinOsc.kr(0.2, 0) * 10 + 21+; var s = LFPulse.ar(f, [0, 0.1], 0.1)+; Out.ar(0, RLPF.ar(s, 100, 0.1).clip2(0.4)) }.play
+ src/mouse-clatter.lhs view
@@ -0,0 +1,55 @@+mouse clatter (rd)++> import Sound.SC3.Monadic++> main =+>   let { x = mouseX kr 100 12000 Linear 0.1+>       ; y = mouseY kr 0.01 0.15 Linear 0.1 }+>   in do { n1 <- lfNoise0 kr (mce [3, 3.25])+>         ; let { t = impulse kr (n1 * 16 + 18) 0+>               ; s = do { n2 <- tRand 0.005 y t+>                        ; n3 <- whiteNoise ar+>                        ; n4 <- tRand 10 x t+>                        ; n5 <- tRand 0 1 t+>                        ; n6 <- tExpRand 0.15 1 t+>                        ; o <- let e = decay2 t 0.01 n2+>                               in return (bpf (n3 * e) n4 n5)+>                        ; n7 <- pv_RandComb (fft' 10 o) n6 t+>                        ; return (o * 0.05 + ifft' n7) } }+>           in withSC3 (\fd -> do { async fd (b_alloc 10 2048 1)+>                                 ; play fd . out 0 =<< s }) }++s.sendMsg('b_alloc', 10, 2048, 1);++{ var x = MouseX.kr(100, 12000, 'linear', 0.1)+; var y = MouseY.kr(0.01, 0.15, 'linear', 0.1)+; var n1 = LFNoise0.kr([3, 3.25])+; var t = Impulse.kr((n1 * 16) + 18, 0)+; var n2 = TRand.kr(0.005, y, t)+; var n3 = WhiteNoise.ar()+; var n4 = TRand.kr(10, x, t)+; var n5 = TRand.kr(0, 1, t)+; var n6 = TExpRand.kr(0.15, 1, t)+; var o = { var e = Decay2.kr(t, 0.01, n2)+          ; BPF.ar(n3 * e, n4, n5) }+; var n7 = PV_RandComb(FFT(10, o), n6, t)+; var s = (o * 0.05) + IFFT(n7)+; Out.ar(0, s) }.play++(let* ((x (MouseX kr 100 12000 0 0.1))+       (y (MouseY kr 0.01 0.15 0 0.1))+       (n1 (LFNoise0 kr (mce2 3 3.25)))+       (t (Impulse kr (MulAdd n1 16 18) 0))+       (n2 (TRand 0.005 y t))+       (n3 (WhiteNoise ar))+       (n4 (TRand 10 x t))+       (n5 (TRand 0.0 1.0 t))+       (n6 (TExpRand 0.15 1.0 t))+       (e (Decay2 t 0.01 n2))+       (o (BPF (Mul n3 e) n4 n5))+       (n7 (PV_RandComb (FFT* 10 o) n6 t))+       (s (Add (Mul o 0.05) (IFFT* n7))))+  (with-sc3+   (lambda (fd)+     (async fd (/b_alloc 10 2048 1))+     (play fd (Out 0 s)))))
+ src/nharm.lhs view
@@ -0,0 +1,26 @@+nharm (rd)++> import Control.Concurrent+> import Control.Monad+> import Sound.SC3.Monadic+> import System.Random++> main =+>   let { nharm n f = map ((* f) . fromIntegral) [1..n]+>       ; rrand l r = getStdRandom (randomR (l, r))+>       ; threadPause n = when (n>0) (threadDelay (floor (n * 1e6)))+>       ; klg m u = do { n <- rrand 4 u+>                      ; d <- rrand 9 12+>                      ; f <- rrand m (m + 2)+>                      ; l <- sequence (replicate n (rrand 0.01 0.02))+>                      ; p <- rrand (-1.0) 1.0+>                      ; let { a = 0.5+>                            ; e = envGen kr 1 0.9 0 1 RemoveSynth (envSine d a)+>                            ; nh = nharm n (midiCPS f)+>                            ; s = klangSpec nh l (replicate n 0.0) }+>                        in return (pan2 (klang ar 1 0 s) p e) }+>       ; ply :: Int -> (Double, Double) -> UGen -> Int -> IO ()+>       ; ply n (l,r) m u = replicateM_ n (do { threadPause =<< rrand l r+>                                             ; audition . out 0 =<< klg m u }) }+>   in do { forkIO (ply 32 (0.25, 0.75) 92 24)+>         ; forkIO (ply 8 (1.25, 1.75) 12 54) }
+ src/noise-burst-sweep.lhs view
@@ -0,0 +1,18 @@+noise burst sweep (jmcc)++> import Sound.SC3.Monadic++> main =+>   do { n <- clone 2 (whiteNoise ar)+>      ; let { lfoRate = mouseX kr 10 60 Exponential 0.2+>            ; amp = max 0 (lfSaw kr lfoRate (-1))+>            ; cfreq = mouseY kr 400 8000 Exponential 0.2+>            ; freq = sinOsc kr 0.2 0 * cfreq + (1.05 * cfreq) }+>        in audition (out 0 (resonz (n * amp) freq 0.1)) }++{ var n = WhiteNoise.ar ! 2+; var lfoRate = MouseX.kr(10, 60, 'exponential', 0.2)+; var amp = max(0, LFSaw.kr(lfoRate, -1))+; var cfreq = MouseY.kr(400, 8000, 'exponential', 0.2)+; var freq = SinOsc.kr(0.2, 0) * cfreq + (1.05 * cfreq)+; Out.ar(0, Resonz.ar(n * amp, freq, 0.1)) }.play
+ src/non-real-time.hs view
@@ -0,0 +1,26 @@+import Sound.OpenSoundControl {- hosc -}+import Sound.SC3+import System.Cmd {- process -}++graph :: UGen+graph =+    let f = control KR "freq" 440+        g = control KR "gain" 0.1+        e = envGen KR 1 1 0 1 RemoveSynth (envPerc 0.1 1.0)+        o = sinOsc AR f 0 * e+    in out 0 (pan2 o 0 g)++score :: [OSC]+score =+    let at t m = Bundle (NTPr t) m+        mk_instr = d_recv (synthdef "test" graph)+        mk_group = g_new [(1, AddToTail, 0)]+        mk_node t f = at t [s_new "test" (-1) AddToTail 1 [("freq", f)]]+        notes = take 128 (zipWith mk_node [0.0, 0.05 ..] [330, 350 ..])+    in at 0.0 [mk_instr, mk_group] : notes++main :: IO ()+main = do+  writeNRT "/tmp/nrt.score" score+  system "scsynth -N /tmp/nrt.score _ /tmp/nrt.wav 44100 WAVE float"+  return ()
+ src/one-line.lhs view
@@ -0,0 +1,14 @@+one-line (lance putnam)++> import Sound.SC3++> main =+>   let { lfs = lfSaw ar (mce2 1 0.99) (mce2 0 0.6) * 2000 + 2000+>       ; lfs_t = trunc lfs (mce2 400 600) * mce2 1 (-1)+>       ; f = onePole (mix lfs_t) 0.98 }+>   in audition (out 0 (pan2 (sinOsc ar f 0) 0 0.1))++{ var lfs = LFSaw.ar([1, 0.99], [0, 0.6], 2000, 2000)+; var lfs_t = lfs.trunc([400, 600]) * [1, -1]+; var f = OnePole.ar(Mix.new(lfs_t), 0.98)+; Out.ar(0, Pan2.ar(SinOsc.ar(f, 0), 0, 0.1)) }.play
+ src/oscillator-cluster.lhs view
@@ -0,0 +1,46 @@+oscillator cluster (rd)++> import Sound.SC3.Monadic++> main =+>   let { ln a b d = line kr a b d RemoveSynth+>       ; rln r a b d = fmap (\n -> ln (a + n) b d) (rand 0 r)+>       ; prt d a cf = do { r1 <- rand cf (cf + 2)+>                         ; r2 <- rln 1 5 0.01 d+>                         ; r3 <- rln 10 20 0 d+>                         ; r4 <- rand 0.1 0.2+>                         ; let { f = mce2 cf r1 + sinOsc kr r2 0 * r3+>                               ; o = fSinOsc ar f 0+>                               ; e = decay2 (impulse ar 0 0) r4 d * a }+>                          in return (o * e) }+>       ; np = 12+>       ; fp = sequence (replicate np (rand 220 660)) }+>   in do { d <- rand 4 7+>         ; a <- rand 0.01 0.05+>         ; audition . (out 0) . sum =<< mapM (prt d a) =<< fp }++{ var ln = { arg a, b, d+           ; Line.kr(a, b, d, 1) }+; var xln = { arg a, b, d+            ; XLine.kr(a, b, d, 1) }+; var rln = { arg r, a, b, d+            ; var n = Rand.new(0, r)+            ; ln.value(a + n, b, d) }+; var rxln = { arg r, a, b, d+             ; var n = Rand.new(0, r)+             ; xln.value(a + n, b, d) }+; var prt = { arg d, a+            ; { arg cf+              ; var r1 = Rand.new(cf, cf + 2)+              ; var r2 = rln.value(1, 5, 0.01, d)+              ; var r3 = rln.value(10, 20, 0, d)+              ; var r4 = Rand.new(0.1, 0.2)+              ; var f = [cf, r1] + (SinOsc.kr(r2, 0) * r3)+              ; var o = FSinOsc.ar(f, 0)+              ; var e = Decay2.ar(Impulse.ar(0, 0), r4, d) * a+              ; o * e } }+; var np = 12+; var fp = Array.fill(np, { Rand.new(220, 660) })+; var d = Rand.new(4, 7)+; var a = Rand.new(0.01, 0.05)+; Out.ar(0, fp.collect(prt.value(d, a)).sum) }.play
+ src/overlap-add.lhs view
@@ -0,0 +1,41 @@+overlap-add (jmcc, rd)++> import Control.Concurrent+> import Sound.OpenSoundControl+> import Sound.SC3.Monadic++> main =+>   let { at t f +>         = let at' t' f' = do { n <- f' t'+>                              ; pauseThreadUntil (t' + n)+>                              ; at' (t' + n) f' }+>           in do { pauseThreadUntil t+>                 ; at' t f+>                 ; return () }+>       ; mk_env a s +>         = let { c = EnvNum 4+>               ; p = envLinen' a s a 1 (c, c, c) }+>           in envGen KR 1 1 0 1 RemoveSynth p+>       ; with_env g a s +>         = out 0 (g * (mk_env a s))+>       ; overlap_add fd n o a s g +>         = do { t <- utcr+>              ; let { g' = with_env g (constant a) (constant s)+>                    ; dt = (a + s + a) / o +>                    ; f _ = do { send fd (s_new n (-1) AddToTail 1 [])+>                               ; return dt } }+>                in do { async fd (d_recv (synthdef n g'))+>                      ; at t f } }+>       ; oSine fd +>         = do { r0 <- expRand 500 1400+>              ; r1 <- rand (-1) 1+>              ; let g = pan2 (sinOsc AR r0 0) r1 0.01+>                in overlap_add fd "random-sines" 4 2 4 g }+>       ; oNoise fd +>         = do { n0 <- whiteNoise AR+>              ; r0 <- expRand 800 8400+>              ; r1 <- rand (-1) 1+>              ; let g = pan2 (resonz (n0 * 0.1) r0 0.05) r1 0.25+>                in overlap_add fd "random-noise" 4 2 4 g } }+>   in do { forkIO (withSC3 (\fd -> oSine fd))+>         ; forkIO (withSC3 (\fd -> oNoise fd)) }
+ src/pattern-buffer.lhs view
@@ -0,0 +1,27 @@+pattern buffer (rd)++> import Sound.SC3.Monadic+> import System.Random++> main =+>   let { nf = 2 * 48000+>       ; c = 24+>       ; tseq l = let n = fromIntegral (length l) / 2.0+>                  in select (lfSaw kr 0.5 0 * n + n) (mce l)+>       ; rrand l r = getStdRandom (randomR (l, r))+>       ; p = phasor ar 0 (bufRateScale kr 10) 0 (bufFrames kr 10) 0+>       ; t = bufRdC 1 ar 10 p Loop +>       ; rs h = do { r0 <- rrand 0 nf+>                   ; r1 <- rrand 0.0 1.0+>                   ; send h (b_set1 10 r0 r1) } }+>   in do { r1 <- sequence (replicate c (rrand 36 96))+>         ; r2 <- sequence (replicate c (rrand (-1.0) 1.0))+>         ; r3 <- rrand 0 1+>         ; n1 <- tRand 0.02 0.08 t+>         ; let { e = decay2 t 0.01 n1+>               ; f = midiCPS (tseq r1)+>               ; l = tseq r2+>               ; o = [sinOsc ar f 0, saw ar f] !! r3 }+>           in withSC3 (\fd -> do { async fd (b_alloc 10 (nf * 2) 1)+>                                 ; sequence (replicate c (rs fd))+>                                 ; play fd (out 0 (pan2 o l e)) }) }
+ src/plucked-strings.lhs view
@@ -0,0 +1,23 @@+plucked strings (jmcc)++> import Sound.SC3.Monadic++> main =+>   let { s = do { n0 <- pinkNoise ar+>                ; r1 <- rand (-1) 1+>                ; im <- i+>                ; dt' <- dt+>                ; let t = decay im 0.1 * n0 * 0.1+>                  in return (pan2 (combL t dt' dt' 4) r1 1) }+>       ; i = do { r0 <- rand 2 2.2+>                ; n0 <- dust ar 0.5+>                ; r1 <- rand 0.05 0.15+>                ; r2 <- rand 0 (pi * 2)+>                ; r3 <- iRand 0 2+>                ; let { s0 = impulse ar r0 0.3+>                      ; s1 = n0 * 0.3+>                      ; s2 = impulse ar (sinOsc kr r1 r2 * 5 + 5.2) 0.3 }+>                  in return (select r3 (mce [s0, s1, s2])) }+>       ; dt = do { r0 <- rand 60 90+>                 ; return (1 / (midiCPS (floorE r0))) } }+>   in audition . out 0 . sum =<< sequence (replicate 5 s)
+ src/police-state.lhs view
@@ -0,0 +1,35 @@+police state (jmcc)++> import Sound.SC3.Monadic++> main =+>   let node = do { r0 <- rand 0.02 0.12+>                 ; r1 <- rand 0 (pi*2)+>                 ; r2 <- rand 0 600+>                 ; r3 <- rand 700 1300+>                 ; r4 <- rand (-1) 1+>                 ; r5 <- rand 80 120+>                 ; n0 <- lfNoise2 ar r5+>                 ; let f = sinOsc kr r0 r1 * r2 + r3+>                   in return (pan2 (sinOsc ar f 0 * n0 * 0.1) r4 1) }+>   in do { nodes <- clone 4 node+>         ; n0 <- clone 2 (lfNoise2 kr 0.4)+>         ; n1 <- lfNoise2 ar (n0 * 90 + 620)+>         ; n2 <- lfNoise2 kr (mce2 0.3 0.301)+>         ; let e = n1 * (n2 * 0.15 + 0.18)+>           in audition (out 0 (combL (mix nodes + e) 0.3 0.3 3)) }++{ var node = { var r0 = Rand.new(0.02, 0.12)+             ; var r1 = Rand.new(0, 2pi)+             ; var r2 = Rand.new(0, 600)+             ; var r3 = 1000 + Rand.new(-300, 300)+             ; var r4 = Rand.new(-1, 1)+             ; var r5 = 100 + Rand.new(-20, 20)+             ; var n0 = LFNoise2.ar(r5)+             ; var f = SinOsc.kr(r0, r1, r2, r3)+             ; Pan2.ar(SinOsc.ar(f, 0) * n0 * 0.1, r4, 1) }+; var n0 = LFNoise2.kr([0.4, 0.4])+; var n1 = LFNoise2.ar(n0 * 90 + 620)+; var n2 = LFNoise2.kr([0.3,0.3])+; var e = n1 * (n2 * 0.15 + 0.18)+; Out.ar(0, CombL.ar(Mix.fill(4, node) + e, 0.3, 0.3, 3)) }.play
+ src/pulsing-bottles.lhs view
@@ -0,0 +1,16 @@+pulsing bottles (jmcc)++> import Control.Monad+> import Sound.SC3.Monadic++> main =+>   let { r = do { n <- whiteNoise ar+>                ; r0 <- rand 4 14+>                ; r1 <- rand 0 0.7+>                ; r2 <- rand 400 7400+>                ; return (resonz (n * lfPulse kr r0 0 0.25 * r1) r2 0.01) }+>       ; s = do { f <- rand 0.1 0.5+>                ; p <- rand 0 (pi * 2)+>                ; return (sinOsc kr f p) }+>       ; u = liftM2 (\x y -> pan2 x y 1) r s }+>   in audition . out 0 . sum =<< sequence (replicate 6 u)
+ src/record-scratcher.lhs view
@@ -0,0 +1,30 @@+record scratcher (josh parmenter)++> import Sound.SC3++> main =+>   let { dup a = mce2 a a+>       ; fn = "/home/rohan/audio/metal.wav"+>       ; d = env [0, 1, 0] [0.1, 0.1] [EnvSin] 1 0+>       ; e = envGen kr 1 1 0 1 RemoveSynth d+>       ; x = mouseX kr (-10) 10 Linear 0.2+>       ; dx = x - delayN x 0.1 0.1+>       ; bdx = mouseButton kr 1 0 0.3 + dx+>       ; bdxr = bdx * bufRateScale kr 0+>       ; scr = playBuf 1 0 bdxr 0 0 Loop DoNothing }+>   in withSC3 (\fd -> do { async fd (b_allocRead 0 fn 0 0)+>                         ; play fd (out 0 (dup (scr * e))) })++{ var fn = "/home/rohan/audio/metal.wav"+; var b = 0+; var gate = 1+; var e = Env.new([0, 1, 0], [0.1, 0.1], \sin, 1, nil)+; var env = EnvGen.kr(e, gate, doneAction: 2)+; var x = MouseX.kr(-10, 10, 'linear', 0.2)+; var dx = x - DelayN.kr(x, 0.1, 0.1)+; var bdx = MouseButton.kr(1, 0, 0.3) + dx+; var bdxr = bdx * BufRateScale.kr(b)+; var scr = PlayBuf.ar(1, b, bdxr, 0, 0, 1)+; var s = Server.default+; s.sendMsg("/b_allocRead", b, fn, 0, 0)+; Out.ar(0, (scr * env).dup ) }.play
+ src/red-frik.lhs view
@@ -0,0 +1,32 @@+red frik (f0)++> import Sound.SC3.Monadic++> main =+>   let red tr n = +>         do { r1 <- tRand 0.3 3 tr+>            ; r2 <- tRand 0.3 5 tr+>            ; r3 <- tRand 0 0.5 tr+>            ; r4 <- tRand 0.49 0.56 tr+>            ; r5 <- tRand 0.3 0.6 tr+>            ; r6 <- tRand 0.3 0.5 tr+>            ; let { o1 = fSinOsc kr r2 0 * r3 + r4+>                  ; o2 = fSinOsc kr o1 r5 * r6 }+>              in return (rhpf n r1 o2) }+>     in do { n <- clone 2 (brownNoise ar)+>           ; let tr = impulse kr 0.1 0+>             in audition . out 0 =<< red tr n }++{ var red = { arg tr, n+            ; var r1 = TRand.kr(0.3, 3, tr)+            ; var r2 = TRand.kr(0.3, 5, tr)+            ; var r3 = TRand.kr(0, 0.5, tr)+            ; var r4 = TRand.kr(0.49, 0.56, tr)+            ; var r5 = TRand.kr(0.3, 0.6, tr)+            ; var r6 = TRand.kr(0.3, 0.5, tr)+            ; var o1 = FSinOsc.kr(r2, 0, r3, r4)+            ; var o2 = FSinOsc.kr(o1, r5, r6)+            ; RHPF.ar(n, r1, o2) }+; var n = [BrownNoise.ar, BrownNoise.ar]+; var tr = Impulse.kr(0.1, 0)+; Out.ar(0, red.value(tr, n)) }.play
+ src/reset.hs view
@@ -0,0 +1,4 @@+import Sound.SC3++main :: IO ()+main = withSC3 reset
+ src/reverberated-sine-percussion.lhs view
@@ -0,0 +1,38 @@+reverberated sine percussion (jmcc)++> import Sound.SC3.Monadic++> main =+>   let { d = 6+>       ; c = 5+>       ; a = 4+>       ; s_ = do { n <- dust ar (2 / constant d)+>                 ; r <- rand 0 3000+>                 ; return (resonz (n * 50) (200 + r) 0.003) }+>       ; x_ i = do { r <- clone 2 (rand 0 0.05)+>                   ; return (allpassN i 0.05 r 1) } +>       ; (>=>) f g = \x -> f x >>= g+>       ; chain n f = foldl (>=>) return (replicate n f) }+>   in do { s <- fmap sum (sequence (replicate d s_))+>         ; y <- let z = delayN s 0.048 0.48+>                in do { r <- clone c (rand 0 0.1)+>                      ; n <- lfNoise1 kr r+>                      ; return (mix (combL z 0.1 (n * 0.04 + 0.05) 15)) }+>         ; x <- chain a x_ y+>         ; audition (out 0 (s + x * 0.2)) }++{ var d = 6+; var c = 5+; var a = 4+; var s_ = { var n = Dust.ar(2 / d)+           ; var r = Rand.new(0, 3000)+           ; Resonz.ar(n * 50, 200 + r, 0.003) }+; var s = Mix.ar(Array.fill(d, s_))+; var z = DelayN.ar(s, 0.048)+; var y_ = LFNoise1.kr(Array.fill(c, { Rand.new(0, 0.1) }), 0.04, 0.05)+; var y = Mix.ar(CombL.ar(z, 0.1, y_, 15))+; var x = y+; var x_ = { var r = [Rand.new(0, 0.05), Rand.new(0, 0.05)]+           ; x = AllpassN.ar(x, 0.050, r, 1) }+; a.do(x_)+; Out.ar(0, s + (0.2 * x)) }.play
+ src/rm-octaver.lhs view
@@ -0,0 +1,10 @@+rm-octaver (andrea valle, miller puckette)++> import Sound.SC3++> main =+>   let { defaultPitch x = pitch x 440 60 4000 100 16 1 0.01 0.5 1+>       ; i = soundIn 0+>       ; p = defaultPitch i+>       ; f = mceChannel 0 p }+>   in audition (out 0 (sinOsc ar (f * 0.5) 0 * i + i))
+ src/s-chirp.lhs view
@@ -0,0 +1,23 @@+s-chirp (rd)++> import Sound.SC3.Monadic++> main =+>   let { x = mouseX kr 15 0 Linear 0.1+>       ; y = mouseY kr 15 27 Linear 0.1+>       ; scl = [0, 2, 3.2, 5, 7, 9, 10] }+>   in do { t <- dust kr 9+>         ; b <- tChoose t (mce [36, 48, 60, 72])+>         ; n <- fmap (* 0.04) (lfNoise1 kr (mce2 3 3.05))+>         ; d <- tiRand x y t+>         ; e <- fmap (decay2 t 0.005) (tRand 0.02 0.15 t)+>         ; o <- let { k = degreeToKey 0 d 12+>                    ; f = midiCPS (b + k + n)+>                    ; m = e * sinOsc ar f 0 * 0.2+>                    ; u = pulseDivider t 9 0 }+>                in do { r0 <- tRand 0.0075 0.125 u+>                      ; r1 <- tRand 0.05 0.15 u+>                      ; return (m * 0.5 + allpassC m 0.15 r0 r1) }+>         ; withSC3 (\fd -> do { async fd (b_alloc 0 7 1)+>                              ; send fd (b_setn1 0 0 scl)+>                              ; play fd (out 0 o) }) }
+ src/sample-and-hold-liquidities.lhs view
@@ -0,0 +1,22 @@+sample and hold liquidities (jmcc)++> import Sound.SC3.ID++> main =+>   let { r = mouseX kr 1 200 Exponential 0.1+>       ; t = recip r+>       ; c = impulse kr r 0.4+>       ; cf = mouseY kr 100 8000 Exponential 0.1+>       ; f = latch (whiteNoise 'α' kr * cf * 0.5 + cf) c+>       ; p = latch (whiteNoise 'β' kr) c+>       ; i = pan2 (sinOsc ar f 0 * decay2 c (t * 0.1) (t * 0.9)) p 1 }+>   in audition (out 0 (combN i 0.3 0.3 2))++{ var r = MouseX.kr(1, 200, 'exponential', 0.1)+; var t = r.reciprocal+; var c = Impulse.kr(r, 0.4)+; var cf = MouseY.kr(100, 8000, 'exponential', 0.1)+; var f = Latch.kr(WhiteNoise.kr * cf * 0.5 + cf, c)+; var p = Latch.kr(WhiteNoise.kr, c)+; var i = Pan2.ar(SinOsc.ar(f, 0, Decay2.kr(c, 0.1 * t, 0.9 * t)), p, 1)+; Out.ar(0, CombN.ar(i, 0.3, 0.3, 2)) }.play
+ src/scratchy-m.lhs view
@@ -0,0 +1,12 @@+scratchy-m (jmcc)++> import Sound.SC3.Monadic++> main =+>   do { n <- clone 2 (brownNoise ar)+>      ; let f = max (n * 0.5 - 0.49) 0 * 20+>        in audition (out 0 (rhpf f 5000 1)) }++{ var n = BrownNoise.ar([0.5, 0.5])+; var f = (n - 0.49).max(0) * 20+; Out.ar(0, RHPF.ar(f, 5000, 1)) }.play
+ src/scratchy.lhs view
@@ -0,0 +1,12 @@+scratchy (jmcc)++> import Sound.SC3.ID++> main =+>   let { f m = brownNoise m ar * 0.5 - 0.49+>       ; n = mce2 (f 'α') (f 'β') }+>   in audition (out 0 (rhpf (max n 0 * 20) 5000 1))++{ var n = BrownNoise.ar([0.5, 0.5])+; var f = (n - 0.49).max(0) * 20+; Out.ar(0, RHPF.ar(f, 5000, 1)) }.play
+ src/scritto.lhs view
@@ -0,0 +1,126 @@+scritto (rd)++> import Sound.SC3.Monadic++> main =+>   let { scritto = [ ( "sA" +>                     , [800, 1150, 2900, 3900, 4950]+>                     , [0, -6,  -32, -20, -50]+>                     , [80, 90,  120, 130, 140] )+>                   , ( "sE" +>                     , [350, 2000, 2800, 3600, 4950]+>                     , [0, -20, -15, -40, -56]+>                     , [60, 100, 120, 150, 200] )+>                   , ( "sI" +>                     , [270, 2140, 2950, 3900, 4950]+>                     , [0, -12 , -26 , -26 , -44]+>                     , [60, 90,  100, 120, 120] )+>                   , ( "sO" +>                     , [450, 800,  2830, 3800, 4950]+>                     , [0, -11 , -22 , -22 , -50]+>                     , [70, 80,  100, 130, 135] )+>                   , ( "sU" +>                     , [325, 700,  2700, 3800, 4950]+>                     , [0, -16, -35, -40, -60]+>                     , [50, 60,  170, 180, 200] )+>                   , ( "aA" +>                     , [800, 1150, 2800, 3500, 4950]+>                     , [0, -4  , -20, -36 , -60]+>                     , [80, 90,  120, 130, 140] )+>                   , ( "aE" +>                     , [400, 1600, 2700, 3300, 4950]+>                     , [0, -24 , -30, -35, -60]+>                     , [60, 80,  120, 150, 200] )+>                   , ( "aI" +>                     , [350, 1700, 2700, 3700, 4950]+>                     , [0, -20, -30, -36 , -60]+>                     , [50, 100, 120, 150, 200] )+>                   , ( "aO" +>                     , [450, 800,  2830, 3500, 4950]+>                     , [0, -9  , -16 , -28 , -55]+>                     , [70, 80,  100, 130, 135] )+>                   , ( "aU" +>                     , [325, 700, 2530, 3500, 4950]+>                     , [0, -12 , -30, -40, -64]+>                     , [50, 60,  170, 180, 200] )+>                   , ( "ctA"+>                     , [660, 1120, 2750, 3000, 3350]+>                     , [0, -6  , -23 , -24 , -38]+>                     , [80, 90,  120, 130, 140] )+>                   , ( "ctE"+>                     , [440, 1800, 2700, 3000, 3300]+>                     , [0, -14 , -18 , -20, -20]+>                     , [70, 80,  100, 120, 120] )+>                   , ( "ctI"+>                     , [270, 1850, 2900, 3350, 3590]+>                     , [0, -24 , -24 , -36 , -36]+>                     , [40, 90,  100, 120, 120] )+>                   , ( "ctO"+>                     , [430, 820,  2700, 3000, 3300]+>                     , [0, -10, -26 , -22 , -34]+>                     , [40, 80,  100, 120, 120] )+>                   , ( "ctU"+>                     , [370, 630,  2750, 3000, 3400]+>                     , [0, -20, -23 , -30, -34]+>                     , [40, 60,  100, 120, 120] )+>                   , ( "tA" +>                     , [650, 1080, 2650, 2900, 3250]+>                     , [0, -6   , -7  , -8 , -22]+>                     , [80, 90,  120, 130, 140] )+>                   , ( "tE" +>                     , [400, 1700, 2600, 3200, 3580]+>                     , [0, -14 , -12 , -14 , -20]+>                     , [70, 80,  100, 120, 120] )+>                   , ( "tI" +>                     , [290, 1870, 2800, 3250, 3540]+>                     , [0, -15, -18 , -20, -30]+>                     , [40, 90,  100, 120, 120] )+>                   , ( "tO" +>                     , [400, 800,  2600, 2800, 3000]+>                     , [0, -10, -12 , -12 , -26]+>                     , [40, 80,  100, 120, 120] )+>                   , ( "tU" +>                     , [350, 600,  2700, 2900, 3300]+>                     , [0, -20, -17 , -14 , -26]+>                     , [40, 60,  100, 120, 120] )+>                   , ( "bA" +>                     , [600, 1040, 2250, 2450, 2750]+>                     , [0, -7   , -9  , -9 , -20]+>                     , [60, 70,  110, 120, 130] )+>                   , ( "bE" +>                     , [400, 1620, 2400, 2800, 3100]+>                     , [0, -12  , -9 , -12 , -18]+>                     , [40, 80,  100, 120, 120] )+>                   , ( "bI" +>                     , [250, 1750, 2600, 3050, 3340]+>                     , [0, -30, -16 , -22 , -28]+>                     , [60, 90,  100, 120, 120] )+>                   , ( "bO" +>                     , [400, 750,  2400, 2600, 2900]+>                     , [0, -11 , -21 , -20, -40]+>                     , [40, 80,  100, 120, 120] )+>                   , ( "bU" +>                     , [350, 600,  2400, 2675, 2950]+>                     , [0, -20, -32 , -28 , -36]+>                     , [40, 80,  100, 120, 120] ) ]+>       ; s_msg n (_, f, a, b) = b_setn1 n 0 (f ++ a ++ b)+>       ; s_alloc fd (s, b) = do { async fd (b_alloc b 15 1)+>                                ; send fd (s_msg b s) }+>       ; buf_at b n = bufRd 1 kr b (mce [n .. n + 4]) NoLoop NoInterpolation+>       ; v_filter i f a b = resonz i f (b / f) * dbAmp a+>       ; v_filter_b bi i = v_filter i (buf_at bi 0) (buf_at bi 5) (buf_at bi 10)+>       ; mk_instr bx = do +>           { n <- lfNoise2 kr 3+>           ; let { t = impulse ar (n * 9 + 9) 0+>                 ; i d = do { n1 <- tRand 0.02 0.06 t+>                            ; n2 <- tiRand 30 52 t+>                            ; n3 <- tiRand 16 32 t+>                            ; let { p = pulseDivider t d 0+>                                  ; b = blip ar (midiCPS n2) n3 }+>                              in return (decay2 p 0.01 n1 * b * 12) }+>                 ; bi = linLin n (-1) 1 0 bx+>                 ; voice = mix . v_filter_b bi }+>             in return . out 0 . mce . map voice =<< mapM i [1, 2] } }+>   in withSC3 (\fd -> do { mapM_ (s_alloc fd) (zip scritto [0..])+>                         ; let n = constant (length scritto)+>                           in audition =<< mk_instr n })
+ src/shepard-tones.lhs view
@@ -0,0 +1,42 @@+shepard tones (alberto de campo)++> import Sound.SC3++> main =+>   let { indxs n l r = let i = (r - l) / n +>                       in [l, l + i .. r - i]+>       ; hanningWindow n = +>             let { lp = pi * (-0.5)+>                 ; rp = lp + 2 * pi +>                 ; hf i = sin i * 0.5 + 0.5 }+>             in map hf (indxs n lp rp)+>       ; square x = x * x+>       ; ampTable = map square (hanningWindow 1024) +>       ; amp_f i = (0.5 ** i) * 20000+>       ; freqTable = map amp_f (indxs 1024 0 10)+>       ; ratescale = 1024 / 44100 / 10+>       ; rate = 0.1+>       ; ph = phasor ar 0 (rate * ratescale) 0 1024 0+>       ; phases = mce (map (\n -> n * 0.1 * 1024 + ph) [0..9])+>       ; freqs = bufRdC 1 ar 1 phases Loop+>       ; amps = bufRdC 1 ar 2 phases Loop+>       ; tone = mix (sinOsc ar freqs 0 * amps) * 0.1 }+>   in withSC3 (\fd -> do { async fd (b_alloc 1 1024 1)+>                         ; async fd (b_alloc 2 1024 1)+>                         ; send fd (b_setn1 1 0 freqTable)+>                         ; send fd (b_setn1 2 0 ampTable)+>                         ; audition (out 0 tone) })++{ var ampTable = Signal.hanningWindow(1024).squared+; var amp_f = { arg i; 0.5 ** i * 20000 }+; var freqTable = Signal.newClear(1024).waveFill(amp_f, 0, 10)+; var b1 = Buffer.loadCollection(s, freqTable)+; var b2 = Buffer.loadCollection(s, ampTable)+; var ratescale = 1024 / 44100 / 10+; var rate = 0.1+; var ph = Phasor.ar(0, rate * ratescale, 0, 1024, 0)+; var phases = (0..9) * 0.1 * 1024 + ph+; var freqs = BufRd.ar(1, b1.bufnum, phases)+; var amps = BufRd.ar(1, b2.bufnum, phases)+; var tone = Mix.ar(SinOsc.ar(freqs) * amps) * 0.1 +; Out.ar(0, tone)}.play
+ src/shifting-pulses.lhs view
@@ -0,0 +1,23 @@+shifting pulses (rd)++> import Sound.SC3.Monadic++> main =+>   do { [n0, n1, n2] <- sequence (replicate 3 (clone 2 (brownNoise kr)))+>      ; t <- dust kr 0.75+>      ; let { warp i = linLin i (-1) 1+>            ; l = latch t t+>            ; p = pulse ar (warp n0 2 (mce2 11 15)) 0.01 * 0.1 +>            ; f = warp n1 300 1800 +>            ; rq = warp n2 0.01 2 }+>        in audition (out 0 (l * rlpf p f rq)) }++{ var n0 = BrownNoise.kr.dup+; var n1 = BrownNoise.kr.dup+; var n2 = BrownNoise.kr.dup+; var t = Dust.kr(0.75)+; var l = Latch.kr(t, t)+; var p = Pulse.ar(n0.range(2, [11, 15]), 0.01) * 0.1 +; var f = n1.range(300, 1800)+; var rq = n2.range(0.01, 2)+; Out.ar(0, l * RLPF.ar(p, f, rq)) }.play
+ src/snare-909.lhs view
@@ -0,0 +1,46 @@+snare-909 (jmcc)++> import Sound.SC3.Monadic++> main =+>   let { snr tr n v =+>         let { e a b = envGen ar tr 1 0 1 DoNothing (envPerc a b)+>             ; e1 = e 0.0005 0.055+>             ; e2 = e 0.0005 0.075+>             ; e3 = e 0.0005 0.4+>             ; e4 = e 0.0005 0.283+>             ; t1 = lfTri ar 330 0+>             ; t2 = lfTri ar 185 0+>             ; x1 = lpf n 7040 * 0.1 + v+>             ; x2 = hpf x1 523+>             ; m1 = t1 * e1 * 0.25 + t2 * e2 * 0.25+>             ; m2 = x1 * e3 * 0.20 + x2 * e4 * 0.20 }+>         in m1 + m2+>       ; x = mouseX kr 1 4 Linear 0.2+>       ; y = mouseY kr 0.25 0.75 Exponential 0.2+>       ; t = impulse kr (3 * x) 0 }+>   in do { n <- whiteNoise ar+>         ; v <- tRand 0.25 1.0 t+>         ; audition (out 0 (pan2 (snr t n v) 0 y)) }++{ var snr =+      { arg tr, n, v+      ; var e = { arg a, b+                ; EnvGen.ar(Env.perc(a, b), tr, 1, 0, 1, 0) }+      ; var e1 = e.value(0.0005, 0.055)+      ; var e2 = e.value(0.0005, 0.075)+      ; var e3 = e.value(0.0005, 0.4)+      ; var e4 = e.value(0.0005, 0.283)+      ; var t1 = LFTri.ar(330, 0)+      ; var t2 = LFTri.ar(185, 0)+      ; var x1 = LPF.ar(n, 7040) * (0.1 + v)+      ; var x2 = HPF.ar(x1, 523)+      ; var m1 = (t1 * e1 * 0.25) + (t2 * e2 * 0.25)+      ; var m2 = (x1 * e3 * 0.20) + (x2 * e4 * 0.20)+      ; m1 + m2 }+; var x = MouseX.kr(1, 4, 'linear', 0.2)+; var y = MouseY.kr(0.25, 0.75, 'exponential', 0.2)+; var t = Impulse.kr(3 * x, 0)+; var n = WhiteNoise.ar+; var v = TRand.kr(0.25, 1.0, t)+; Out.ar(0, Pan2.ar(snr.value(t, n, v), 0, y)) }.play
+ src/sosc-lp.lhs view
@@ -0,0 +1,34 @@+sosc-lp (rd)++> import Sound.SC3.Monadic++> main =+>   let { dustR r lo hi = do { n1 <- dwhite 1 lo hi+>                            ; n2 <- whiteNoise r+>                            ; d <- dseq dinf n1+>                            ; return (tDuty r d 0 DoNothing (abs n2) 1) }+>       ; a = [60, 71, 89, 65, 36, 57, 92, 97, 92, 97]+>       ; b = [71, 89, 60, 57, 65, 36, 95, 92, 93, 97]+>       ; setup fd = do { async fd (b_alloc 10 9 1)+>                       ; async fd (b_alloc 11 9 1)+>                       ; send fd (b_setn1 10 0 a)+>                       ; send fd (b_setn1 11 0 b) }+>       ; d_env t = decay2 t 0.002 2.5+>       ; idx t = stepper t 0 0 15 1 0+>       ; f1 t = let { l = (bufRdL 1 kr 10 (idx t) Loop - 24)+>                    ; r = (bufRdL 1 kr 11 (idx t) Loop - 24) }+>                in midiCPS (mce2 l r)+>       ; f2 t n = f1 t + n * 1.2+>       ; o1 t = sinOsc ar (f1 t) 0 * d_env t+>       ; o2 t n = sinOsc ar (f2 t n) 0 * d_env t+>       ; sosc_lp t n = out 0 ((o1 t + o2 t n) * 0.2) }+>   in do { clk <- dustR kr 0.2 0.9+>         ; n <- lfNoise0 kr (mce2 1 3)+>         ; audition (sosc_lp clk n) }++> resetter =+>   let { a = [71, 60, 65, 89, 36, 57, 95, 97, 92, 97]+>       ; b = [89, 71, 60, 65, 57, 36, 92, 95, 93, 97]+>       ; resetup fd = do { send fd (b_setn1 10 0 a)+>                         ; send fd (b_setn1 11 0 b) } }+>   in withSC3 resetup
+ src/spe.lhs view
@@ -0,0 +1,23 @@+spe (jmcc)++> import Sound.SC3.Monadic++> main =+>   let { (>=>) f g = \x -> f x >>= g+>       ; chain n f = foldl (>=>) return (replicate n f)+>       ; rapf i = do { r <- clone 2 (rand 0 0.05)+>                     ; return (allpassN i 0.05 r 4) }+>       ; src = let { t = impulse kr 9 0+>                   ; e = envGen kr t 0.1 0 1 DoNothing (envPerc 0.1 1)+>                   ; s = mce [ 00, 03, 02, 07+>                             , 08, 32, 16, 18+>                             , 00, 12, 24, 32 ] }+>               in do { n <- lfNoise1 kr 1+>                     ; m <- dseq dinf s+>                     ; let { f = midiCPS (demand t 0 m + 32)+>                           ; o = lfSaw ar f 0 * e+>                           ; rq = midiCPS (n * 36 + 110) }+>                       in return (rlpf o rq 0.1) } }+>   in audition . (out 0) =<< chain 4 rapf =<< src++[variant of graph in streams & patterns tutorial]
+ src/sprinkler-m.lhs view
@@ -0,0 +1,13 @@+sprinkler-m (jmcc)++> import Sound.SC3.Monadic++> main =+>   do { n <- whiteNoise ar+>      ; let { f = lfPulse kr 0.09 0 0.16 * 10 + 7+>            ; t = lfPulse kr f 0 0.25 * 0.1 }+>        in audition (out 0 (bpz2 (n * t))) }++{ var f = LFPulse.kr(0.09, 0, 0.16, 10, 7)+; var t = LFPulse.kr(f, 0, 0.25, 0.1)+; Out.ar(0, BPZ2.ar(WhiteNoise.ar * t)) }.play
+ src/sprinkler.lhs view
@@ -0,0 +1,13 @@+sprinkler (jmcc)++> import Sound.SC3.ID++> main =+>   let { n = whiteNoise 'α' AR+>       ; f = lfPulse KR 0.09 0 0.16 * 10 + 7+>       ; t = lfPulse KR f 0 0.25 * 0.1 }+>   in audition (out 0 (bpz2 (n * t)))++{ var f = LFPulse.kr(0.09, 0, 0.16, 10, 7)+; var t = LFPulse.kr(f, 0, 0.25, 0.1)+; Out.ar(0, BPZ2.ar(WhiteNoise.ar * t)) }.play
+ src/strummable-guitar.lhs view
@@ -0,0 +1,27 @@+strummable guitar (jmcc)++> import Sound.SC3.ID++> main =+>   let { scale = [ 52, 57, 62, 67, 71, 76 ]+>       ; str i = let { x = mouseX kr 0 1 Linear 0.2+>                     ; t = abs (hpz1 (x >* (0.25 + constant i * 0.1)))+>                     ; e = decay t 0.05+>                     ; n = pinkNoise i ar * e+>                     ; dt = 1 / (midiCPS (scale !! i))+>                     ; s = combL n dt dt 4 }+>                 in pan2 s (constant i * 0.2 - 0.5) 1+>       ; strs = mixFill (length scale) str }+>   in audition (out 0 (leakDC (lpf strs 12000) 0.995))++{ var scale = [ 52, 57, 62, 67, 71, 76 ]+; var str = { arg i+            ; var x = MouseX.kr(0, 1, 'linear', 0.2)+            ; var t = HPZ1.kr(x > (0.25 + (i * 0.1))).abs+            ; var e = Decay.kr(t, 0.05)+            ; var n = PinkNoise.ar * e+            ; var dt = scale.at(i).midicps.reciprocal+            ; var s = CombL.ar(n, dt, dt, 4)+            ; Pan2.ar(s, i * 0.2 - 0.5, 1) }+; var strs = Mix.fill(scale.size, str)+; Out.ar(0, LeakDC.ar(LPF.ar(strs, 12000), 0.995)) }.play
+ src/sweepy-noise.lhs view
@@ -0,0 +1,17 @@+sweepy noise (jmcc)++> import Sound.SC3.Monadic++> main =+>   do { n <- clone 2 (whiteNoise ar)+>      ; let { lfoDepth = mouseY kr 200 8000 Exponential 0.1+>            ; lfoRate = mouseX kr 4 60 Exponential 0.1+>            ; freq = lfSaw kr lfoRate 0 * lfoDepth + (lfoDepth * 1.2)+>            ; filtered = rlpf (n * 0.03) freq 0.1 }+>        in audition (out 0 (combN filtered 0.3 0.3 2 + filtered)) }++{ var lfoDepth = MouseY.kr(200, 8000, 'exponential', 0.1)+; var lfoRate = MouseX.kr(4, 60, 'exponential', 0.1)+; var freq = LFSaw.kr(lfoRate, 0) * lfoDepth + (lfoDepth * 1.2)+; var filtered = RLPF.ar(WhiteNoise.ar([0.03,0.03]), freq, 0.1)+; Out.ar(0, CombN.ar(filtered, 0.3, 0.3, 2) + filtered) }.play
+ src/synthetic-piano.lhs view
@@ -0,0 +1,33 @@+synthetic piano (jmcc)++> import Sound.SC3.Monadic++> main =+>   let p = do { n <- iRand 36 90+>              ; f <- rand 0.1 0.5+>              ; ph <- rand 0 (pi * 2)+>              ; let { s = impulse ar f ph * 0.1+>                    ; e = decay2 s 0.008 0.04+>                    ; c i = do { n0 <- lfNoise2 ar 3000+>                               ; let { o = [-0.05, 0, 0.04] !! i+>                                     ; dt = 1 / (midiCPS (n + o)) }+>                                 in return (combL (n0 * e) dt dt 6) }+>                    ; l = ((n - 36) / 27) - 1 }+>                in do { c_ <- mixFillM 3 c+>                      ; return (pan2 c_ l 1) } }+>   in audition . out 0 =<< mixFillM 6 (const p)++{ var p = { var n = IRand.new(36, 90)+          ; var f = Rand.new(0.1, 0.5)+          ; var ph = Rand.new(0, pi * 2)+          ; var s = Impulse.ar(f, ph) * 0.1+          ; var e = Decay2.ar(s, 0.008, 0.04)+          ; var c = { arg i+                    ; var n0 = LFNoise2.ar(3000)+                    ; var o = [-0.05, 0, 0.04].at(i)+                    ; var dt = 1 / (n + o).midicps+                    ; CombL.ar(n0 * e, dt, dt, 6) }+          ; var l = ((n - 36) / 27) - 1+          ; var c_ = Mix.fill(3, c)+          ; Pan2.ar(c_, l, 1) }+; Out.ar(0, Mix.fill(6, p)) }.play
+ src/tank.lhs view
@@ -0,0 +1,64 @@+tank (jmcc)++> import Control.Monad+> import Sound.SC3.Monadic++> main =+>   let { r_allpass i = do { r <- clone 2 (rand 0.005 0.02)+>                          ; return (allpassN i 0.03 r 1) }+>       ; chain n f = foldl (>=>) return (replicate n f)+>       ; pling = do { d <- dust ar 0.2+>                    ; f <- expRand 300 2200+>                    ; p <- rand (-1) 1+>                    ; let { s1 = cubed (fSinOsc ar f 0)+>                          ; s2 = decay2 d 0.1 0.5 * 0.1 * s1 }+>                      in return (pan2 s2 p 1) }+>       ; bang = do { d <- dust ar 0.01+>                   ; n <- brownNoise ar+>                   ; return (pan2 (decay2 d 0.04 0.3 * n) 0 1) }+>       ; tank i = do { r1 <- clone 2 (rand 0.01 0.05)+>                     ; r2 <- clone 2 (rand 0.03 0.15)+>                     ; let { l0 = localIn 2 ar * 0.98+>                           ; l1 = onePole l0 0.33+>                           ; [l1l, l1r] = mceChannels l1+>                           ; l2 = rotate2 l1l l1r 0.23+>                           ; l3 = allpassN l2 0.05 r1 2+>                           ; l4 = delayN l3 0.3 (mce [0.17, 0.23])+>                           ; l5 = allpassN l4 0.05 r2 2+>                           ; l6 = leakDC l5 0.995+>                           ; l7 = l6 + i }+>                       in return (mrg [l7, localOut l7]) }+>       ; signal = do { s <- liftM2 (+) bang (mixFillM 8 (const pling))+>                     ; chain 4 r_allpass s } }+>   in audition . out 0 =<< tank =<< signal++{ var r_allpass = { arg signal+                  ; var r = { Rand.new(0.005, 0.02) }.dup+                  ; AllpassN.ar(signal, 0.03, r, 1); }+; var pling = { var d = Dust.ar(0.2)+              ; var f = ExpRand.new(300, 2200)+              ; var p = Rand.new(-1, 1)+              ; var s1 = FSinOsc.ar(f, 0).cubed+              ; var s2 = Decay2.ar(d, 0.1, 0.5) * 0.1 * s1+              ; Pan2.ar(s2, p, 1) }+; var bang = { var d = Dust.ar(0.01)+             ; var n = BrownNoise.ar+             ; Pan2.ar(Decay2.ar(d, 0.04, 0.3) * n, 0, 1) }+; var tank = { arg i+             ; var r1 = { Rand.new(0.01,0.05) }.dup+             ; var r2 = { Rand.new(0.03,0.15) }.dup+             ; var l0 = LocalIn.ar(2) * 0.98+             ; var l1 = OnePole.ar(l0, 0.33)+             ; var l2 = Rotate2.ar(l1[0], l1[1], 0.23)+             ; var l3 = AllpassN.ar(l2, 0.05, r1, 2)+             ; var l4 = DelayN.ar(l3, 0.3, [0.17,0.23])+             ; var l5 = AllpassN.ar(l4, 0.05, r2, 2)+             ; var l6 = LeakDC.ar(l5, 0.995)+             ; var l7 = l6 + i+             ; LocalOut.ar(l7)+             ; l7 }+; var signal = Mix.fill(12, pling) + bang.value+; 4.do({ signal = r_allpass.value(signal) })+; Out.ar(0, tank.value(signal)) }.play++http://create.ucsb.edu/pipermail/sc-users/2004-April/009692.html
+ src/tgb.lhs view
@@ -0,0 +1,33 @@+tgb (rd)++> import Sound.SC3.Monadic+> import System.Random++> main =+>   let { mkls bp t = envGen kr 1 1 0 1 RemoveSynth (envCoord bp t 1 EnvLin)+>       ; pm_t l r d t = let { le = mkls l d+>                            ; re = mkls r d }+>                        in tRand le re t+>       ; wrp i l r = linLin i (-1) 1 l r+>       ; pm_n rt l d = let { le = mkls l d+>                           ; re = mkls l d }+>                       in do { n <- whiteNoise rt+>                             ; return (wrp n le re) }+>       ; gb b d = do { gps <- pm_n ar [(0, 400), (1, 900)] d+>                     ; let { t = impulse ar gps 0+>                           ; pm_f (l, r) = pm_t l r d t }+>                       in do { du <- pm_f ([(0, 0.005), (0.5, 0.015), (1, 0.005)]+>                                          ,[(0, 0.009), (0.5, 0.020), (1, 0.009)])+>                             ; pn <- pm_f ([(0, -1.0), (0.5, -0.5), (1, 0.5)]+>                                          ,[(0, -0.5), (0.5, 0.5), (1, 1.0)])+>                             ; rt <- pm_f ([(0, 6), (0.5, 12), (1, 6)]+>                                          ,[(0, 12), (0.5, 12), (1, 12)])+>                             ; cs <- pm_f ([(0, 0), (1, 0.95)]+>                                          ,[(0, 0), (1, 1)])+>                             ; am <- pm_f ([(0, 0.25), (0.5, 0.55), (1, 0.15)]+>                                          ,[(0, 0.5), (0.5, 0.75), (1, 0.25)])+>                             ; let cs' = cs * (bufDur kr b)+>                               in return (tGrains 2 t b rt cs' du pn am 2) } }+>       ; fn = "/home/rohan/audio/text.snd" }+>   in withSC3 (\fd -> do { async fd (b_allocRead 10 fn 0 0)+>                         ; play fd . (out 0) =<< gb 10 12 })
+ src/tgr-rpr.lhs view
@@ -0,0 +1,42 @@+tgr-rpr (rd)++> import Sound.OpenSoundControl+> import Sound.SC3.Monadic+> import System.Random++> main =+>   let { sf = "/home/rohan/audio/text.snd"+>       ; preset = [ 0.01, 0.02+>                  , 0.95, 1.05+>                  , 0.02, 0.06+>                  , 0.2, 0.3+>                  , 0.7, 0.9+>                  , -1.0, 1.0 ]+>       ; dustR r lo hi = do { n1 <- dwhite 1 lo hi+>                            ; n2 <- whiteNoise r+>                            ; d <- dseq dinf n1+>                            ; return (tDuty r d 0 DoNothing (abs n2) 1) }+>       ; rpr n t = tRand (in' 1 kr n) (in' 1 kr (n + 1)) t+>       ; rrand l r = getStdRandom (randomR (l, r))+>       ; rSet = [ (0.005, 0.025), (0.05, 0.25)+>                , (0.75,  0.95) , (1.05, 1.25)+>                , (0.001, 0.01) , (0.02, 0.04)+>                , (0.1,   0.2)  , (0.2, 0.4)+>                , (0.0,   0.45) , (0.55, 1.0)+>                , (-1.0,  0.0)  , (0.0, 1.0) ]+>       ; edit fd = do { s <- mapM (\(l,r) -> rrand l r) rSet+>                      ; send fd (c_setn [(0, s)])+>                      ; pauseThread 0.35 } }+>   in do { clk <- dustR ar (in' 1 kr 0) (in' 1 kr 1)+>         ; rat <- rpr 2 clk+>         ; dur <- rpr 4 clk+>         ; pos <- fmap (* (bufDur kr 10)) (rpr 8 clk)+>         ; pan <- rpr 10 clk+>         ; amp <- rpr 6 clk+>         ; withSC3 (\fd -> do { async fd (b_allocRead 10 sf 0 0)+>                              ; send fd (c_setn [(0, preset)])+>                              ; let o = tGrains 2 clk 10 rat pos dur pan amp 2+>                                in play fd (out 0 o)+>                              ; pauseThread 0.3+>                              ; sequence (replicate 16 (edit fd))+>                              ; reset fd }) }
+ src/tgrn.lhs view
@@ -0,0 +1,20 @@+tgrn (rd)+ghci -e main tgrn.lhs+C-cC-l C-cC-m++> import Sound.SC3.ID++> tgrn b =+>   let { trate = mouseY kr 2 120 Exponential 0.1+>       ; dur = 1.2 / trate+>       ; clk = impulse ar trate 0+>       ; pos = mouseX kr 0 (bufDur kr b) Linear 0.1+>       ; pan = whiteNoise 'α' kr * 0.6+>       ; n = roundE (whiteNoise 'β' kr * 3) 1+>       ; rate = shiftLeft 1.2 n }+>   in tGrains 2 clk b rate pos dur pan 0.25 2++> main =+>   let fn = "/home/rohan/audio/text.snd"+>   in withSC3 (\fd -> do { async fd (b_allocRead 10 fn 0 0)+>                         ; audition (out 0 (tgrn 10)) })
+ src/theremin.lhs view
@@ -0,0 +1,22 @@+theremin (jmcc)++> import Sound.SC3++> main =+>   let { m = 7+>       ; detune = 0+>       ; x = mouseX kr 0 0.9 Linear 0.2+>       ; y = mouseY kr 4000 200 Exponential 0.8+>       ; f = y + detune+>       ; f' = f + f * sinOsc ar m 0 * 0.02+>       ; a = sinOsc ar f' 0 * x }+>   in audition (out 0 (pan2 a 0 1))++{ var mod = 7+; var detune = 0+; var x = MouseX.kr(0, 0.9, 'linear', 0.2)+; var y = MouseY.kr(4000, 200, 'exponential', 0.8)+; var f = y + detune+; var f_ = f + (f * SinOsc.ar(mod, 0) * 0.02)+; var a = SinOsc.ar(f_, 0) * x+; Out.ar(0, (Pan2.ar(a, 0, 1))) }.play
+ src/three-cpsw.lhs view
@@ -0,0 +1,24 @@+three-cpsw (rd)++> import Sound.SC3.Monadic++> main =+>   do { t <- dust kr (mce2 12 18)+>      ; f0 <- tRand 1 64 t+>      ; f1 <- lfNoise0 kr f0+>      ; a <- tRand 0.0 0.5 t+>      ; dt <- tRand 0.975 1.025 t+>      ; dh <- tRand 0.750 0.7505 t+>      ; let { f = f1 * mce2 9000 12000 + 9500+>            ; o = saw ar f + saw ar (f * dh) + saw ar (f * dt) }+>        in audition (out 0 (clip2 (o * a) 0.75)) }++{ var t = Dust.kr([12, 18])+; var f0 = TRand.kr(1, 64, t)+; var f1 = LFNoise0.kr(f0)+; var a = TRand.kr(0.0, 0.5, t)+; var dt = TRand.kr(0.975, 1.025, t)+; var dh = TRand.kr(0.750, 0.7505, t)+; var f = f1 * [9000, 12000] + 9500+; var o = Saw.ar(f) + Saw.ar(f * dh) + Saw.ar(f * dt)+; Out.ar(0, (o * a).clip2(0.75)) }.play
+ src/thx.lhs view
@@ -0,0 +1,38 @@+thx (perry cook)++> import Sound.SC3+> import System.Random++> main =+>   let { rvb i rT +>           = let { d = mce [0.0297, 0.0371, 0.0411, 0.0437]+>                 ; c = mix (combN i 0.05 d rT * 0.25)+>                 ; f = (allpassN c 0.01 0.005 0.096835) }+>             in allpassN f 0.01 0.0017 0.032924+>       ; mk_env z0 t0 z1 t1 t2 z2 t3 c+>           = let { z = [z0, z1, z1, z2, z2]+>                 ; t = [t0, t1, t2, t3]+>                 ; e = env z t [c, c, c] (-1.0) (-1.0) }+>             in envGen KR 1 1 0 1 RemoveSynth e+>       ; mk_node t4 f0 f1 l +>           = let { f = mk_env f0 t0 f0 t1 t2 f1 (t3 + t4 + t5 + t5) EnvLin+>                 ; g = mk_env 0 t0 0.1 (t1 + t2 + t3) t4 0.0 (t5 + t5) EnvLin+>                 ; s = saw AR f+>                 ; t0 = 0.035+>                 ; t1 = 0.2267573696+>                 ; t2 = 2.2675736061+>                 ; t3 = 6.8027210884+>                 ; t5 = 1.75 }+>             in pan2 s l g+>       ; thx +>           = let { s = foldl1 (+) (zipWith3 (mk_node t4) f0 f1 l)+>                 ; t4 = 7.9365079365+>                 ; n = 30+>                 ; l = take n (randomRs (-1.0, 1.0) (mkStdGen 1))+>                 ; f = [29, 87.5, 116, 175, 233, 350, 524, 880, 1048, 1760]+>                 ; f0 = take n (randomRs (200.0, 800.0) (mkStdGen 2))+>                 ; f1 = take n (cycle f) }+>             in out 0 (rvb (mce [s]) t4) }+>   in audition thx++http://ccrma-mail.stanford.edu/pipermail/stk/2007-January/000327.html
+ src/tipnso.lhs view
@@ -0,0 +1,15 @@+tipnso (rd)++> import Sound.SC3.Monadic++> main =+>   let { x = mouseX kr 1 32 Linear 0.1+>       ; t = impulse ar x 0 }+>   in do { n1 <- tiRand 16 72 t+>         ; n2 <- tiRand 0 1 t+>         ; n3 <- pinkNoise ar+>         ; let { e = decay2 t 0.01 (mce2 0.1 0.15)+>               ; f = midiCPS (n1 + 36 + (12 * n2))+>               ; s = sinOsc ar f 0 * e+>               ; b = bpf (n3 * e) (36 + midiCPS n1) (175 / (midiCPS n1)) }+>           in audition (out 0 ((s + b) * mce2 0.15 0.1)) }
+ src/tr-out.lhs view
@@ -0,0 +1,23 @@+tr-out (rd)++> import Sound.SC3.Monadic++> main =+>   let node n = do { t <- dust kr 1.6+>                   ; r1 <- tRand 0 6 t+>                   ; r2 <- tRand 0 6 t+>                   ; r3 <- tRand 0 6 t+>                   ; let { f = midiCPS (bufRdN 1 kr 0 r1 NoLoop)+>                         ; p = bufRdN 1 kr 1 r2 NoLoop+>                         ; a = bufRdN 1 kr 2 r3 NoLoop }+>                     in return ( pan2 (sinOsc ar f 0) p a+>                               , sendTrig t n (f / 660) ) }+>   in withSC3 (\fd -> do { async fd (b_alloc 0 6 1)+>                         ; send fd (b_setn1 0 0 [60, 62, 64, 65, 67, 69])+>                         ; async fd (b_alloc 1 6 1)+>                         ; send fd (b_setn1 1 0 [-1, -0.5, 0, 0.25, 0.75, 1.0])+>                         ; async fd (b_alloc 2 6 1)+>                         ; send fd (b_setn1 2 0 [0.01, 0.05, 0.1, 0.15, 0.25, 0.35])+>                         ; ns <- mapM node [1..4]+>                         ; let o = sum (map fst ns)+>                           in play fd (out 0 (mrg (o : map snd ns))) })
+ src/train.lhs view
@@ -0,0 +1,25 @@+train (th.list at gmail.com)++> import Sound.SC3.Monadic++> main =+>   let { time = 24+>       ; steam n1 n2 = let { piston = lfSaw AR (xLine AR 1 7 time DoNothing) 0+>                           ; air = lpf (n1 * piston + n2 * piston) 5000 +>                           ; e = envGen AR 1 1 0 1 DoNothing (envSine time 9) }+>                       in bpf air 600 (1 + e)+>       ; whistle n3 = let { f = [800, 600, 1200, 990]+>                          ; s = klankSpec f [1, 1, 1, 1] [1, 1, 1, 1]+>                          ; t = [0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 0]+>                          ; l = [2, 0, 0.2, 0, 0.2, 0, 0.8, 0, 4, 0, 3]+>                          ; d = env t l (repeat EnvLin) 0 0+>                          ; e = envGen AR 1 1 0 (time/10) DoNothing d }+>                      in klank (n3 * 0.004) 1 0 1 s * e+>       ; loc = let e = env [-0.8, 0.8] [time + 2] [EnvSin, EnvSin] 0 0+>               in envGen AR 1 1 0 1 RemoveSynth e }+>   in do { n1 <- whiteNoise AR+>         ; n2 <- pinkNoise AR+>         ; n3 <- whiteNoise AR+>         ; audition (out 0 (pan2 (steam n1 n2 + whistle n3) loc 1)) }++http://www.create.ucsb.edu/pipermail/sc-users/2007-August/035957.html
+ src/trkl.lhs view
@@ -0,0 +1,27 @@+trkl (rd)++> import Sound.SC3.Monadic++> main =+>   let trkl d ul fu dy la fy =+>           let { tf = xLine kr 1 ul d RemoveSynth+>               ; st = impulse ar (tf * 8) 0+>               ; t = impulse ar tf 0 }+>           in do { r0 <- rand (-1) 1+>                 ; r1 <- rand (-1) 1+>                 ; r2 <- tRand 0.05 1.0 t+>                 ; r3 <- tExpRand 0.0 0.25 st +>                 ; fh <- tRand 1.75 2.25 t +>                 ; let { a = dbAmp (line kr 12 la d RemoveSynth)+>                       ; f = xLine kr fu 900 d RemoveSynth+>                       ; p = line kr r0 r1 d RemoveSynth+>                       ; o1 = mix (ringz (decay2 t 0.01 dy) (mce2 f (f * fh)) fy)+>                       ; o2 = mix (saw ar (mce2 f (f * fh))) }+>                  in return (pan2 (o1 + o2 * decay2 t 0.1 r2 * r3) p a) }+>   in do { d <- rand 0.5 16+>         ; ul <- rand 16 64+>         ; fu <- rand 1200 9000+>         ; dy <- rand 0.005 0.175+>         ; la <- rand (-60) (-25)+>         ; fy <- rand 0.015 0.125+>         ; audition . (out 0) =<< trkl d ul fu dy la fy }
+ src/tsort.lhs view
@@ -0,0 +1,22 @@+tsort (jmcc)++This simple graph tests the topological sort of the unit generator+graph, it ought only to use a minimal number of interconnect buffers.++The below 369 node graph works with 'scsynth -u 57110 -w 2'.  ++(Note that graphs loaded from disk during startup will grow the number+of interconnect buffers, so to test this we must delete all graphs that+would otherwise be loaded.)++> import Sound.SC3++> main =+>   let { n = 122+>       ; c = envCoord [(0,0), (0.15, 1), (6, 0)] 1 1 EnvLin+>       ; e = envGen kr 1 1 0 1 RemoveSynth c+>       ; f o = sinOsc ar (440 + constant o) 0 * 0.001+>       ; s = mixFill n f }+>   in audition (out 0 (s * e))++http://create.ucsb.edu/pipermail/sc-users/2003-March/002807.html
+ src/vlc-distrtn.lhs view
@@ -0,0 +1,133 @@+vlc-distrtn (rd)+caution - audio feedback graph++> import Sound.OpenSoundControl+> import Sound.SC3.Monadic+> import System.Random++> main =+>   let { rrand l r = getStdRandom (randomR (l, r))+>       ; choose l = return . (l !!) =<< rrand 0 (length l - 1)+>       ; prep (ampl, phase) = [dbAmp ampl, phase]+>       ; vlc = [ (0.00000, 1.85550)+>               , (-9.92383, -0.65147)+>               , (-8.74205, -0.74728)+>               , (-3.70464, -1.39796)+>               , (-9.43435, -1.14812)+>               , (-25.84790, -1.03375)+>               , (-16.99500, -2.41724)+>               , (-29.17040, 2.67419)+>               , (-26.82750, -1.61810)+>               , (-18.59870, 1.34568)+>               , (-19.72160, -2.85972)+>               , (-29.43650, 0.54603)+>               , (-23.63120, -1.47813)+>               , (-28.20100, -1.98501)+>               , (-41.20700, -1.11808)+>               , (-33.14310, -2.19369)+>               , (-31.54010, 1.43134)+>               , (-47.62740, 1.28571)+>               , (-28.79740, -1.03754)+>               , (-34.97950, 0.37740)+>               , (-39.05770, -0.57557)+>               , (-38.84060, 2.34836)+>               , (-40.18090, -0.96978)+>               , (-47.32150, 2.14768)+>               , (-45.49290, 2.52100)+>               , (-40.57100, -1.39905)+>               , (-47.19530, -2.23994)+>               , (-50.80920, 2.97853)+>               , (-48.13640, 0.46815)+>               , (-58.56890, -1.01821)+>               , (-57.81200, -3.08971)+>               , (-47.96870, -0.48657)+>               , (-43.96100, -0.10311)+>               , (-50.49810, -2.80977)+>               , (-50.61640, -0.17212)+>               , (-60.64640, -1.02433)+>               , (-58.03410, 1.06921)+>               , (-55.46390, -2.04501)+>               , (-54.31000, -1.53512)+>               , (-52.78670, -1.49875)+>               , (-57.99380, 0.17697)+>               , (-56.76990, 2.28241)+>               , (-54.17450, -1.85553)+>               , (-62.58220, -2.40971)+>               , (-59.86460, 1.04782)+>               , (-61.58570, 1.56183)+>               , (-52.62080, 1.68360)+>               , (-49.82940, -1.11019)+>               , (-56.18160, -0.78538)+>               , (-57.73320, -2.23918)+>               , (-49.87560, 3.09604)+>               , (-51.00100, -0.53762)+>               , (-59.71530, 0.99017)+>               , (-65.73280, 2.43855)+>               , (-73.01270, -0.90664)+>               , (-61.81450, -0.53346)+>               , (-65.58980, 1.51174)+>               , (-75.94320, -3.06072)+>               , (-65.22210, -1.49937)+>               , (-70.79970, -2.96199)+>               , (-64.72450, 1.78172)+>               , (-73.24130, 0.26939)+>               , (-66.17110, -0.23305)+>               , (-61.32910, -3.12592)+>               , (-66.98180, 0.64700)+>               , (-65.23060, -2.94395)+>               , (-70.13430, 1.29805)+>               , (-68.43470, -1.35906)+>               , (-71.33000, -2.71582)+>               , (-86.90080, 2.11646)+>               , (-74.97450, 2.76118)+>               , (-68.02520, 0.94979)+>               , (-67.32960, 3.05994)+>               , (-67.32140, -2.79905)+>               , (-68.22010, -2.33831) ]+>       ; partial b i freq detune fall n =+>           do { n0 <- lfNoise1 kr 1+>              ; n1 <- rand 0.75 1.25+>              ; let { m = n * 2+>                    ; ampl = bufRdN 1 kr b m NoLoop+>                    ; f = freq * (n + 1) * (n0 * detune + 1) }+>                in return (ringz i f (fall * n1) * ampl) }+>       ; plyr n =+>           let { ctl j k = control kr j k+>               ; buf = ctl "buf" 0+>               ; iamp = ctl "iamp" 0.1+>               ; ampl = ctl "ampl" 0.1+>               ; freq = ctl "freq" 129.897+>               ; fall = ctl "fall" 0.5+>               ; loc = ctl "loc" 0.0+>               ; detune = ctl "detune" 0.001+>               ; i = soundIn 0 * iamp }+>           in do { s <- mapM (partial buf i freq detune fall) [0 .. n-1]+>                 ; return (out 0 (clip2 (pan2 (sum s) loc ampl) 0.1)) }+>       ; degree_to_key degree scale steps =+>           let scale_n = length scale+>           in (steps * (degree `div` scale_n)) + (scale !! (degree `mod` scale_n))+>       ; getCps b =+>           do { b_ <- choose b+>              ; d <- choose [0 .. 8]+>              ; let k = degree_to_key d [0, 2, 3, 5, 7, 8, 10] 12+>                in return (midiCPS (b_ + realToFrac k)) }+>       ; pattern fd =+>           do { f <- getCps [24, 36, 48, 55, 60]+>              ; ia <- rrand 0.05 0.75+>              ; l <- rrand (-1) 1+>              ; a <- rrand 0.05 0.1+>              ; d <- rrand 0.001 0.005+>              ; fl <- rrand 1 7+>              ; send fd (n_set 1002 [("freq", f)+>                                    ,("iamp", ia)+>                                    ,("buf", 0)+>                                    ,("loc", l)+>                                    ,("ampl", a)+>                                    ,("detune", d)+>                                    ,("fall", fl)])+>              ; pauseThread =<< choose [0.25, 0.5, 0.75, 1.5] } }+>   in withSC3 (\fd -> do { async fd (b_alloc 0 (length vlc * 2) 1)+>                         ; send fd (b_setn1 0 0 (concatMap prep vlc))+>                         ; async fd . d_recv . synthdef "plyr48" =<< plyr 48+>                         ; send fd (s_new "plyr48" 1002 AddToTail 1 [])+>                         ; sequence (replicate 32 (pattern fd)) })
+ src/waveset.hs view
@@ -0,0 +1,155 @@+{- A simple waveset synthesiser (rd) -}++import Control.Monad+import qualified Data.Array as A {- array -}+import Data.List+import qualified Sound.File.NeXT as F {- hsc3-sf -}+import Sound.OpenSoundControl {- hosc -}+import Sound.SC3+import System.Environment+import System.Random {- random -}++-- * Score model.++-- | Interval to schedule in advance.+latency :: Double+latency = 0.15++-- | Add t to timestamp.+offset :: Double -> OSC -> OSC+offset t (Bundle (UTCr t0) m) = Bundle (UTCr (t + t0)) m+offset _ _ = undefined++-- | Play non-empty set of osc bundles.+play_set :: Transport t => t -> [OSC] -> IO ()+play_set _ [] = undefined+play_set fd (x:xs) = do+  let (Bundle (UTCr t) _) = x+  pauseThreadUntil (t - latency)+  mapM_ (\e -> send fd e) (x:xs)++-- | Play grouped score.+play_sets :: Transport t => t -> [[OSC]] -> IO ()+play_sets _ [] = return ()+play_sets fd s = do+  t <- utcr+  mapM_ (play_set fd) (map (\g -> map (offset t) g) s)++-- | Split l into chunks of at most n elements.+form_sets :: Int -> [a] -> [[a]]+form_sets _ [] = []+form_sets n l =+    let (a,b) = splitAt n l+    in a : form_sets n b++-- | Play score, send in sets on indicated cardinality.+play_score :: Transport t => Int -> t -> [OSC] -> IO ()+play_score n fd s = play_sets fd (form_sets n s)++-- * Waveset analysis++-- | Zero-crossing predicate.+is_zc :: (Num a, Ord a) => a -> a -> Bool+is_zc a b = a <= 0 && b > 0++-- | Locate fractional zero-crossing point.+locate_fzc :: (Ord a, Fractional a) => a -> a -> a+locate_fzc x y = (1.0 / (y - x)) * abs x++-- | Fractional zero-crossing constructor, n is the initial frame location.+fzc :: (Ord a, Fractional a) => a -> [a] -> [a]+fzc _ [] = []+fzc _ [_] = []+fzc n (x:y:z) = if is_zc x y+                then (n + locate_fzc x y) : fzc (n + 2.0) z+                else fzc (n + 1.0) (y : z)++-- | Remove zero crossings so that no waveset has length less than m.+prune :: (Ord a, Num a) => a -> a -> [a] -> [a]+prune _ _ [] = [] -- hmmm....+prune m n (x:xs) = if (x - n) < m+                   then prune m n xs+                   else x : prune m x xs++-- | zc -> ws+ws :: [a] -> [(a,a)]+ws [] = []+ws [_] = []+ws (x:y:z) = (x,y) : ws (y : z)++-- * Waveset instrument++-- | A trivial waveset instrument with unit envelope.+waveset :: UGen+waveset =+    let k = control KR+        o = k "out" 0+        b = k "bufnum" 0+        s = k "start" 0+        e = k "end" 0+        r = k "rate" 1+        d = k "dur" 1+        a = k "amp" 0.2+        rs = bufRateScale KR b * r+        ph = phasor AR 0 rs 0 (e - s) 0 + s+        e_data = env [a, a, 0] [d, 0] [EnvLin] (-1) (-1)+        e_ugen = envGen AR 1 1 0 1 RemoveSynth e_data+    in offsetOut o (bufRdL 1 AR b ph Loop * e_ugen)++-- * Waveset synthesizer++-- | Construct s_new message for synthesiser.+mk_msg :: Double -> Double -> Double -> Double -> OSC+mk_msg b sf ef d =+    let a = [("bufnum", b), ("start", sf), ("end", ef), ("dur", d)]+    in s_new "waveset" (-1) AddToTail 1 a++-- | Compare wavesets by duration.+dur_ord :: (Num t, Ord t) => (t, t) -> (t, t) -> Ordering+dur_ord (s0, e0) (s1, e1) = compare (e0 - s0) (e1 - s1)++-- | Generate score from waveset data.+mk_score :: Double -> [Double] -> [(Double, Double)] -> [OSC]+mk_score sr repeats w =+    let durations = zipWith (\(s, e) r -> (e - s) * r / sr) w repeats+        start_times = scanl (+) 0 durations+        mk_elem (s,e) t d = Bundle (UTCr t) [mk_msg 10 s e d]+    in zipWith3 mk_elem w start_times durations++-- | n randomly chosen elements of w.+rchoose :: Int -> [a] -> [a]+rchoose n w =+    let (l, r) = (1, length w)+        a = A.listArray (l,r) w+    in take n (map (a A.!) (randomRs (l,r) (mkStdGen 1)))++-- | Load waveset instrument, allocate sound file buffer, do waveset+--   analysis, generate & play scores.+run_waveset :: Transport t => t -> String -> IO ()+run_waveset fd fn = do+  async fd (d_recv (synthdef "waveset" waveset))+  async fd (b_allocRead 10 fn 0 0)+  (hdr, cs) <- F.read fn+  let nc = F.channelCount hdr+      nf = F.frameCount hdr+      sr = fromIntegral (F.sampleRate hdr)+      b = cs !! 0+      w = ws (prune 64 0 (fzc 0 b))+      pl s = play_score 10 fd s >> pauseThread 1+  putStrLn ("#f: " ++ show (nc, nf, sr))+  putStrLn ("#w: " ++ show (length w)) -- force w+  pl (mk_score sr (repeat 1) w)+  pl (mk_score sr (repeat 2) (reverse w))+  pl (mk_score sr (cycle [2,4,8]) (sortBy dur_ord w))+  pl (mk_score sr (randomRs (1,24) (mkStdGen 2)) (rchoose 512 w))++main :: IO ()+main = do+  a <- getArgs+  case a of+    [fn] -> withSC3 (\fd -> run_waveset fd fn)+    _ -> error "audio file?"++{--+withSC3 (\fd -> run_waveset fd "/home/rohan/audio/text.snd")+--}
+ src/what-was-i-thinking.lhs view
@@ -0,0 +1,34 @@+what was i thinking? (jmcc)++> import Sound.SC3.Monadic++> main =+>   do { n0 <- lfNoise1 kr 0.2+>      ; n1 <- lfNoise1 kr 0.157+>      ; let { p = pulse ar f (n1 * 0.4 + 0.5) * 0.04+>            ; i = lfPulse ar 0.1 0 0.05 * impulse ar 8 0 * 500+>            ; d = decay i 2+>            ; f = max (sinOsc kr 4 0 + 80) d+>            ; z = rlpf p (n0 * 2000 + 2400) 0.2+>            ; c x = do { r <- rand 0 0.3+>                       ; n <- lfNoise1 kr r+>                       ; return (combL x 0.06 (n * 0.025 + 0.035) 1) }+>            ; y = z * 0.6 }+>        in do { z0 <- clone 2 (c y)+>              ; z1 <- clone 2 (c y)+>              ; audition (out 0 (z + mce [mix z0, mix z1])) } }++{ var n0 = LFNoise1.kr(0.2, 2000, 2400)+; var n1 = LFNoise1.kr(0.157, 0.4, 0.5)+; var i = LFPulse.ar(0.1, 0, 0.05) * Impulse.ar(8, 0) * 500+; var d = Decay.ar(i, 2)+; var f = max(SinOsc.kr(4, 0) + 80, d)+; var p = Pulse.ar(f, n1) * 0.04+; var z = RLPF.ar(p, n0, 0.2)+; var c = { arg i+          ; var r = Rand.new(0, 0.3)+          ; var n = LFNoise1.kr(r, 0.025, 0.035)+          ; CombL.ar(i, 0.06, n, 1) }+; var y = z * 0.6+; Out.ar(0, z + [ c.value(y) + c.value(y)+                , c.value(y) + c.value(y) ]) }.play
+ src/wial.lhs view
@@ -0,0 +1,22 @@+wial (rd)++> import Sound.SC3.Monadic++> main =+>   let { pls c d f = let { t = pulseDivider c d 0+>                         ; e = decay2 t 0.05 0.75+>                         ; o = sinOsc ar (toggleFF t * f + f * 2) 0 }+>                      in do { n0 <- tiRand 0 1 t+>                            ; return (o * e * n0 * 0.5) }+>       ; smpl f = [ (4, 6, f      , 0.75)+>                  , (2, 6, f *   2, 0.75)+>                  , (1, 2, f *  16, 0.025)+>                  , (1, 5, f *  64, 0.005)+>                  , (1, 4, f * 128, 0.035)+>                  , (1, 3, f * 256, 0.15)+>                  , (2, 3, f * 512, 0.35) ]+>       ; plss c (d0, d1, f, a) = fmap (* a) (pls c (mce2 d0 d1) f)+>       ; clk = impulse ar 16 0 }+>   in do { n0 <- dust kr 2+>         ; f <- twChoose n0 (mce2 (20 * 0.66) 20) (mce2 0.25 0.75) 0+>         ; audition . out 0 . sum =<< mapM (plss clk) (smpl f) }
+ src/wind-metals.lhs view
@@ -0,0 +1,29 @@+wind metals (jmcc)++> import Sound.SC3.Monadic++> main =+>   let n = 6+>   in do { base <- expRand 60 4000+>         ; range <- rand 500 8000+>         ; n0 <- clone 2 (brownNoise ar)+>         ; r0 <- expRand 0.125 0.5+>         ; n1 <- lfNoise1 kr r0+>         ; f <- sequence (replicate n (rand base (base + range)))+>         ; dt <- sequence (replicate n (rand 0.1 2))+>         ; let { exc = n0 * 0.007 * max 0 (n1 * 0.75 + 0.25)+>               ; k = klankSpec f (replicate n 1) dt+>               ; s = klank exc 1 0 1 k }+>           in audition (out 0 (softClip (s * 0.1))) }++{ var n = 6+; var base = ExpRand.new(60, 4000)+; var range = Rand.new(500.0, 8000.0)+; var n0 = BrownNoise.ar([0.007, 0.007])+; var r0 = ExpRand.new(0.125, 0.5)+; var n1 = LFNoise1.kr(r0, 0.75, 0.25)+; var exc = n0 * max(0, n1)+; var f = Array.fill(n, { Rand.new(0, range) + base })+; var dt = Array.fill(n, { Rand.new(0.1, 2.0) })+; var s = Klank.ar(`[f, nil, dt], exc)+; Out.ar(0, (s * 0.1).softclip) }.play
+ src/xy-interference-m.lhs view
@@ -0,0 +1,20 @@+xy-interference-m (rd)++> import Sound.SC3.Monadic++> main =+>   let { x = mouseX KR 20 22000 Linear (mce2 0.005 0.025)+>       ; y = mouseY KR 20 22000 Linear (mce2 0.005 0.075)+>       ; nd = do { n <- lfNoise0 KR (mce2 5 9)+>                 ; let { a = sinOsc AR (x + n) 0+>                       ; b = sinOsc AR y 0 }+>                   in return (a * b) } }+>   in audition . (out 0) . sum =<< sequence (replicate 3 nd)++{ var x = MouseX.kr(20, 22000, 'linear', [0.005, 0.025])+; var y = MouseY.kr(20, 22000, 'linear', [0.005, 0.075])+; var nd = { var n = LFNoise0.kr([5, 9])+           ; var a = SinOsc.ar(x + n, 0)+           ; var b = SinOsc.ar(y, 0)+           ; a * b }+; Out.ar(0, Mix.fill(3, nd)) }.play
+ src/xy-interference.lhs view
@@ -0,0 +1,20 @@+xy-interference (rd)++> import Sound.SC3.ID++> main =+>   let { x = mouseX KR 20 22000 Linear (mce2 0.005 0.025)+>       ; y = mouseY KR 20 22000 Linear (mce2 0.005 0.075)+>       ; nd k = let { n = lfNoise0 k KR (mce2 5 9)+>                    ; a = sinOsc AR (x + n) 0+>                    ; b = sinOsc AR y 0 }+>                in a * b }+>   in audition (out 0 (sum (map nd ['α'..'γ'])))++{ var x = MouseX.kr(20, 22000, 'linear', [0.005, 0.025])+; var y = MouseY.kr(20, 22000, 'linear', [0.005, 0.075])+; var nd = { var n = LFNoise0.kr([5, 9])+           ; var a = SinOsc.ar(x + n, 0)+           ; var b = SinOsc.ar(y, 0)+           ; a * b }+; Out.ar(0, Mix.fill(3, nd)) }.play