h&:      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                  !"""""""""""""######$$$%%%%%%%%%%%%%%%%&&&&&&&&&'''(((((((()))))))))))))))))))))))))))))))))))))))**********************************************************************************+++++++,,, , , , , , - - - - - . . . . . . . . . . . . . . . . . . . . . . . . . . . . / / / / / / / / / 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 2 2 2 2 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 4 4 5 5 6 6 6 6 6 6 7 7 7 7 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 9 9 9 : : : : : : : : : : : : : ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<<<<<========================================================================================================================================================================================================================================================================================================================================================================================================================================================================================>>>>>>??????@@@@@@@@@@@@@@@@@@AAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBCCCCCCDDDDDDDDDDDDDDDEEEEEEFFFFFFFFFGGGGGGGGGGGGGGGGGGGGHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIIIIIIIIIIIJJJJKKKKKKKKKKKKKKKKKKKKKLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNOOOOOOOOOOOOOOOOOOOPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRSSSSSSSSSSSSSTTTTTUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVVVVVVVVVWWWWWWWWWWWWWWWWWWW Safe-InferredJ}1hsc3 Four-tuple.hsc3 Three-tuple.hsc3 Two-tuple.hsc3Ci = Case insensitive, Cs = case sensitive, Sci = separator & case insensitivehsc311-parameter function.hsc310-parameter function. hsc36-parameter function. hsc35-parameter function. hsc3Quaternary function. hsc3Ternary function. hsc3Binary function.hsc3Unary function.hsc3Apply f n times, ie. iterate f x !! n -iter 3 (* 2) 1 == 8 iterate (* 2) 1 !! 3 == 8hsc3This is the same function as Control.Monad.void, which however hugs does not know of.hsc3 Variant of  requiring exact match.hsc3Similar to Data.List.Split.splitOn, which however hugs doesn't know of. string_split_at_char ':' "/usr/local/bin:/usr/bin:/bin" == ["/usr/local/bin","/usr/bin","/bin"] string_split_at_char ':' "/usr/local/bin" == ["/usr/local/bin"]hsc3String equality with . string_eq Ci "sinOsc" "SinOsc" == True string_eq Sci "sin-osc" "SinOsc" == Truehsc3 of .hsc3 parser with . #parse_enum Ci "false" == Just Falsehsc31Left to right composition of a list of functions. compose_l [(* 2),(+ 1)] 3 == 7hsc31Right to left composition of a list of functions. compose_r [(* 2),(+ 1)] 3 == 8hsc3$SequenceableCollection.differentiate '> [3,4,1,1].differentiate == [3,1,-3,0] 8d_dx [3,4,1,1] == [3,1,-3,0] d_dx [0,1,3,6] == [0,1,2,3]hsc31Variant that does not prepend zero to input, ie.  of . 6d_dx' [3,4,1,1] == [1,-3,0] d_dx' [0,1,3,6] == [1,2,3]hsc3 SequenceableCollection.integrate "> [3,4,1,1].integrate == [3,7,8,9] dx_d [3,4,1,1] == [3,7,8,9] dx_d (d_dx [0,1,3,6]) == [0,1,3,6] dx_d [0.5,0.5] == [0.5,1]hsc3$Variant pre-prending zero to output. dx_d' [3,4,1,1] == [0,3,7,8,9] dx_d' (d_dx' [0,1,3,6]) == [0,1,3,6] dx_d' [0.5,0.5] == [0,0.5,1]hsc3 with equality function.hsc3Erroring variant.hsc3Reverse  with equality function.hsc3(prev,cur,next) triples. pcn_triples [1..3] == [(Nothing,1,Just 2),(Just 1,2,Just 3),(Just 2,3,Nothing)] hsc3Separate first list element. *sep_first "astring" == Just ('a',"string")!hsc3Separate last list element. )sep_last "stringb" == Just ("string",'b')"hsc3Are lists of equal length? equal_length_p ["t1","t2"] == True equal_length_p ["t","t1","t2"] == False#hsc3 Histogram$hsc3!! with localised error message%hsc3concat of intersperse. This is the same function as intercalate, which hugs doesn't know of.&hsc3Similar to Data.List.Split.splitOn, which however hugs doesn't know of. list_split_at_elem ' ' "a sequence of words" == ["a","sequence","of","words"]'hsc36Data.List.sortOn, which however hugs does not know of. 2sort_on snd [('a',1),('b',0)] == [('b',0),('a',1)](hsc3Inserts at the first position where it compares less but not equal to the next element. import Data.Function insertBy (compare `on` fst) (3,'x') (zip [1..5] ['a'..]) insertBy_post (compare `on` fst) (3,'x') (zip [1..5] ['a'..]))hsc3( using .*hsc3Apply f at all but last element, and g at last element. )at_last (* 2) negate [1..4] == [2,4,6,-4]+hsc3Zip two 4-tuples.,hsc3 t -> (t,t)-hsc3 t -> (t,t,t).hsc3t -> (t,t,t,t)/hsc3 of f at x and g at y.0hsc3 Length prefixed list variant of /.1hsc3 of f at x and g at y and h at z.2hsc3 x,y-> (x,y)3hsc3 x,y,z -> (x,y,z)4  !"#$%&'()*+,-./01234  !"#$%&'()*+,-./0123 Safe-InferredL5hsc3 with error handler to return default value. This almost works in hugs (IOException should be Exception, the signature can be elided) get_env_with_default "undefined_environment_variable" "default" -- > "default"6hsc3 with lookup and default value. !get_env_default "PATH" "/usr/bin"7hsc3 with default value. $lookup_env_default "PATH" "/usr/bin"567567 Safe-InferredM8hsc3((moduleName, qualifierName, packageName)9hsc32Format a Context as a sequence of import commands.:hsc3writeFile of context_format;hsc3Minimal hsc3 context<hsc3Standard hsc3 context89:;<89:;< Safe-InferredP=hsc3Unification of integer and Ugen buffer identifiers.@hsc3#Warp interpolation indicator input.Dhsc3 Completion mode indicator input.Jhsc3Interpolation indicator input.Ohsc3Loop indicator input.Phsc30Qhsc31Shsc3Apply f at R.Thsc3Resolve O.Uhsc3Resolve J.Vhsc3Apply f at I.Whsc3Resolve D.Xhsc3Resolve @. +map from_warp [Linear,Exponential] == [0,1]Yhsc3Apply f at CZhsc3fmap is S[hsc3fmap is V\hsc3fmap = Y=>?@CBADIHGFEJNMLKORPQSTUVWXYORPQSTJNMLKUDIHGFEVW@CBAXY=>? Safe-Inferred\ ghsc3(Directory containing Sc3 Rtf help files.hhsc3,Find (case-insensitively) indicated file at g/. Runs the command "find -name" (so Unix only). sc3_rtf_find_file "SinOsc.help.rtf" sc3_rtf_find_file "lfsaw.help.rtf" sc3_rtf_find_file "softClip.rtf"ihsc3 variant.jhsc3Run the command unrtf (so UNIX only) to convert an RTF file to a TEXT (.scd) file.khsc3j of i, writing output to TMPDIRlhsc3k and run editor.mhsc3l with emacsclient --no-wait. #sc3_rtf_help_scd_open_emacs "lfsaw"nhsc32Url for online Sc-Doc SuperCollider documentation.ohsc3Read the environment variable SC3_SCDOC_HTML_HELP_DIR. The default value is !~/.local/share/SuperCollider/Help.phsc3&Path to indicated Sc3 class help file. 6sc3_scdoc_help_class "SinOsc" == "Classes/SinOsc.html"qhsc32Generate path to indicated Sc3 operator help file. ;sc3_scdoc_help_operator "+" == "Overviews/Operators.html#+"rhsc3+Generate path to indicated Sc3 method help. :sc3_scdoc_help_method '*' ("C","m") == "Classes/C.html#*m"shsc31Generate path to indicated Sc3 class method help.  sc3_mul_add x 2 3) [1,5] == [5,13] && map (\x -> sc3_mul_add x 3 2) [1,5] == [5,17]hsc33Ordinary Haskell order (un-optimised) multiply-add. mul_add 3 4 2 == 2 * 3 + 4 map (mul_add 2 3) [1,5] == [5,13] && map (mul_add 3 4) [1,5] == [7,19]hsc3  mul_add_hs (3,4) 2 == 2 * 3 + 4hsc3 of .hsc3 of .hsc3 of .hsc3 of .hsc3 Variant of SC3 roundTo function. sc3_round_to (2/3) 0.25 == 0.75 let r = [0,0,0.25,0.25,0.5,0.5,0.5,0.75,0.75,1,1] map (`sc3_round_to` 0.25) [0,0.1 .. 1] == r map (`sc3_round_to` 5.0) [100.0 .. 110.0]hsc3 of  of .hsc3Least common multiple. This definition extends the usual definition and returns a negative number if any of the operands is negative. This makes it consistent with the lattice-theoretical interpretation and its idempotency, commutative, associative, absorption laws. lcm 4 6 == 12 lcm 1 1 == 1 lcm 1624 26 == 21112 lcm 1624 (-26) /= (-21112) lcm (-1624) (-26) /= (-21112) lcm 513 (gcd 513 44) == 513hsc3Greatest common divisor. This definition extends the usual definition and returns a negative number if both operands are negative. This makes it consistent with the lattice-theoretical interpretation and its idempotency, commutative, associative, absorption laws. ,https://www.jsoftware.com/papers/eem/gcd.htm gcd 4 6 == 2 gcd 0 1 == 1 gcd 1024 256 == 256 gcd 1024 (-256) == 256 gcd (-1024) (-256) /= (-256) gcd (-1024) (lcm (-1024) 256) /= (-1024) gcd 66 54 * lcm 66 54 == 66 * 54hsc3The SC3 % Ugen operator is the  function. > 1.5 % 1.2 // ~= 0.3 > -1.5 % 1.2 // ~= 0.9 > 1.5 % -1.2 // ~= -0.9 > -1.5 % -1.2 // ~= -0.3 let (%) = sc3_mod 1.5 % 1.2 ~= 0.3 (-1.5) % 1.2 ~= 0.9 1.5 % (-1.2) ~= -0.9 (-1.5) % (-1.2) ~= -0.3 > 1.2 % 1.5 // ~= 1.2 > -1.2 % 1.5 // ~= 0.3 > 1.2 % -1.5 // ~= -0.3 > -1.2 % -1.5 // ~= -1.2 1.2 % 1.5 ~= 1.2 (-1.2) % 1.5 ~= 0.3 1.2 % (-1.5) ~= -0.3 (-1.2) % (-1.5) ~= -1.2 ?map (\n -> sc3_mod n 12.0) [-1.0,12.25,15.0] == [11.0,0.25,3.0]hsc3Type specialised .hsc3Type specialised .hsc3SC3 clip function. Clip n to within range (i,j). clip is a Ugen. ?map (\n -> sc3_clip n 5 10) [3..12] == [5,5,5,6,7,8,9,10,10,10]hsc3 Variant of ! with haskell argument structure. 8map (clip_hs (5,10)) [3..12] == [5,5,5,6,7,8,9,10,10,10]hsc3,Fractional modulo, alternate implementation. map (\n -> sc3_mod_alt n 12.0) [-1.0,12.25,15.0] == [11.0,0.25,3.0]hsc3Wrap function that is  non-inclusive' at right edge, ie. the Wrap Ugen rule. map (sc3_wrap_ni 0 5) [4,5,6] == [4,0,1] map (sc3_wrap_ni 5 10) [3..12] == [8,9,5,6,7,8,9,5,6,7] Sound.Sc3.Plot.plot_fn_r1_ln (sc3_wrap_ni (-1) 1) (-2,2)hsc3 sc_wrap::int > [5,6].wrap(0,5) == [5,0] map (wrap_hs_int (0,5)) [5,6] == [5,0] > [9,10,5,6,7,8,9,10,5,6].wrap(5,10) == [9,10,5,6,7,8,9,10,5,6] map (wrap_hs_int (5,10)) [3..12] == [9,10,5,6,7,8,9,10,5,6]hsc3Wrap n to within range (i,j), ie. AbstractFunction.wrap, ie.  inclusive at right edge. wrap is a Ugen, hence prime. > [5.0,6.0].wrap(0.0,5.0) == [0.0,1.0] map (wrap_hs (0,5)) [5,6] == [0,1] map (wrap_hs (5,10)) [3..12] == [8,9,5,6,7,8,9,5,6,7] 4Sound.Sc3.Plot.plot_fn_r1_ln (wrap_hs (-1,1)) (-2,2)hsc3 Variant of  with SC3 argument ordering. map (\n -> sc3_wrap n 5 10) [3..12] == map (wrap_hs (5,10)) [3..12]hsc3Generic variant of wrap'. > [5,6].wrap(0,5) == [5,0] map (generic_wrap (0,5)) [5,6] == [5,0] > [9,10,5,6,7,8,9,10,5,6].wrap(5,10) == [9,10,5,6,7,8,9,10,5,6] map (generic_wrap (5::Integer,10)) [3..12] == [9,10,5,6,7,8,9,10,5,6]hsc3Given sample-rate sr and bin-count n calculate frequency of ith bin. %bin_to_freq 44100 2048 32 == 689.0625hsc31Fractional midi note number to cycles per second. map (floor . midi_to_cps) [0,24,69,120,127] == [8,32,440,8372,12543] map (floor . midi_to_cps) [-36,138] == [1,23679] map (floor . midi_to_cps) [69.0,69.25 .. 70.0] == [440,446,452,459,466]hsc31Cycles per second to fractional midi note number. map (round . cps_to_midi) [8,32,440,8372,12543] == [0,24,69,120,127] map (round . cps_to_midi) [1,24000] == [-36,138]hsc35Cycles per second to linear octave (4.75 = A4 = 440).  [4.0,4.25,4.75].octcps.cpsmidi == [60,63,69] map (cps_to_midi . oct_to_cps) [4.0,4.25,4.75] == [60,63,69]hsc3*Degree, scale and steps per octave to key.hsc3One-indexed piano key number (for standard 88 key piano) to midi note number. -map pianokey_to_midi [1,49,88] == [21,69,108]hsc3Piano key to hertz (ba.pianokey2hz in Faust). This is useful as a more musical gamut than midi note numbers. Ie. if x is in (0,1) then pianokey_to_cps of (x * 88) is in (26,4168) map (round . pianokey_to_cps) [0,1,40,49,88] == [26,28,262,440,4186] map (round . midi_to_cps) [0,60,69,127] == [8,262,440,12544]hsc3Linear amplitude to decibels. map (round . amp_to_db) [0.01,0.05,0.0625,0.125,0.25,0.5] == [-40,-26,-24,-18,-12,-6]hsc3Decibels to linear amplitude.map (floor . (* 100). db_to_amp) [-40,-26,-24,-18,-12,-6] == [01,05,06,12,25,50]let amp = map (2 **) [0 .. 15] let db = [0,-6 .. -90] map (round . ampDb . (/) 1) amp == db map (round . amp_to_db . (/) 1) amp == db zip amp dbdb_to_amp (-3) == 0.7079457843841379 amp_to_db 0.7079457843841379 == -3hsc36Fractional midi note interval to frequency multiplier. >map midi_to_ratio [-12,0,7,12] == [0.5,1,1.4983070768766815,2]hsc3 Inverse of . 3map ratio_to_midi [3/2,2] == [7.019550008653875,12]hsc3sr = sample rate, r = cycle (two-pi), cps = frequency cps_to_incr 48000 128 375 == 1 cps_to_incr 48000 two_pi 458.3662361046586 == 6e-2hsc3 Inverse of . incr_to_cps 48000 128 1 == 375hsc37Pan2 function, identity is linear, sqrt is equal power.hsc3 Linear pan. map (lin_pan2 1) [-1,-0.5,0,0.5,1] == [(1,0),(0.75,0.25),(0.5,0.5),(0.25,0.75),(0,1)]hsc3Equal power pan. !map (eq_pan2 1) [-1,-0.5,0,0.5,1]hsc3 of .hsc3 a^2 - b^2.hsc3Euclidean distance function ( of sum of squares).hsc3&Sc3 hypotenuse approximation function.hsc3Fold k to within range (i,j), ie. AbstractFunction.fold 8map (foldToRange 5 10) [3..12] == [7,6,5,6,7,8,9,10,9,8]hsc3 Variant of  with SC3 argument ordering.hsc3SC3 distort operator.hsc3SC3 softclip operator.hsc39True is conventionally 1. The test to determine true is > 0.hsc3:False is conventionally 0. The test to determine true is <= 0.hsc3Lifted . ;sc3_not sc3_true == sc3_false sc3_not sc3_false == sc3_truehsc3 Translate  to  and .hsc3Lift comparison function.hsc3Lifted .hsc3Lifted .hsc3Lifted .hsc3Lifted .hsc3Lifted .hsc3Lifted .hsc3Clip a value that is expected to be within an input range to an output range, according to a rule. let f r = map (\x -> apply_clip_rule r 0 1 (-1) 1 x) [-1,0,0.5,1,2] in map f [minBound .. maxBound]hsc32Scale uni-polar (0,1) input to linear (l,r) range.hsc37Scale (0,1) input to linear (l,r) range. u = uni-polar. 'map (urange 3 4) [0,0.5,1] == [3,3.5,4]hsc3/Calculate multiplier and add values for (-1,1)  transform. range_muladd 3 4 == (0.5,3.5)hsc3Scale bi-polar (-1,1) input to linear (l,r) range. Note that the argument order is not the same as linLin.hsc3Scale (-1,1) input to linear (l,r) range. Note that the argument order is not the same as linlin. Note also that the various range Ugen methods at sclang select mul-add values given the output range of the Ugen, ie LFPulse.range selects a (0,1) input range. map (range 3 4) [-1,0,1] == [3,3.5,4] map (\x -> let (m,a) = linlin_muladd (-1) 1 3 4 in x * m + a) [-1,0,1] == [3,3.5,4]hsc3 hsc3 !. This allows cases such as osc  (0,1)hsc3(Calculate multiplier and add values for linlin transform. Inputs are: input-min input-max output-min output-max range_muladd 3 4 == (0.5,3.5) linlin_muladd (-1) 1 3 4 == (0.5,3.5) linlin_muladd 0 1 3 4 == (1,3) linlin_muladd (-1) 1 0 1 == (0.5,0.5) linlin_muladd (-0.3) 1 (-1) 1hsc32Map from one linear range to another linear range. &linlin_ma hs_muladd 5 0 10 (-1) 1 == 0hsc3linLin with a more typical haskell argument structure, ranges as pairs and input last. map (linlin_hs (0,127) (-0.5,0.5)) [0,63.5,127] == [-0.5,0.0,0.5]hsc32Map from one linear range to another linear range. r = [0,0.125,0.25,0.375,0.5,0.625,0.75,0.875,1] map (\i -> sc3_linlin i (-1) 1 0 1) [-1,-0.75 .. 1] == rhsc3Given enumeration from dst! that is in the same relation as n is from src. linlin _enum_plain 'a' 'A' 'e' == 'E' linlin_enum_plain 0 (-50) 16 == -34 linlin_enum_plain 0 (-50) (-1) == -51hsc3 Variant of  that requires src and dst& ranges to be of equal size, and for n to lie in src. linlin_enum (0,100) (-50,50) 0x10 == Just (-34) linlin_enum (-50,50) (0,100) (-34) == Just 0x10 linlin_enum (0,100) (-50,50) (-1) == Nothinghsc3Erroring variant.hsc3 Variant of linlin that requires src and dst6 ranges to be of equal size, thus with constraint of  and  instead of . linlin_eq (0,100) (-50,50) 0x10 == Just (-34) linlin_eq (-50,50) (0,100) (-34) == Just 0x10hsc3Erroring variant.hsc3Linear to exponential range conversion. Rule is as at linExp Ugen, haskell manner argument ordering. Destination values must be nonzero and have the same sign. map (floor . linexp_hs (1,2) (10,100)) [0,1,1.5,2,3] == [1,10,31,100,1000] map (floor . linexp_hs (-2,2) (1,100)) [-3,-2,-1,0,1,2,3] == [0,1,3,10,31,100,316]hsc3 Variant of  with argument ordering as at linExp Ugen. map (\i -> lin_exp i 1 2 1 3) [1,1.1 .. 2] map (\i -> floor (lin_exp i 1 2 10 100)) [0,1,1.5,2,3]hsc3SimpleNumber.linexp* shifts from linear to exponential ranges. %map (sc3_linexp 1 2 1 3) [1,1.1 .. 2] > [1,1.5,2].collect({|i| i.linexp(1,2,10,100).floor}) == [10,31,100] map (floor . sc3_linexp 1 2 10 100) [0,1,1.5,2,3] == [10,10,31,100,100]hsc3SimpleNumber.explin is the inverse of linexp. .map (sc3_explin 10 100 1 2) [10,10,31,100,100]hsc30Translate from one exponential range to another. )map (sc3_expexp 0.1 10 4.3 100) [1 .. 10]hsc3Map x from an assumed linear input range (src_l,src_r) to an exponential curve output range (dst_l,dst_r). curve is like the parameter in Env. Unlike with linexp, the output range may include zero. > (0..10).lincurve(0,10,-4.3,100,-3).round == [-4,24,45,61,72,81,87,92,96,98,100] let f = round . sc3_lincurve (-3) 0 10 (-4.3) 100 in map f [0 .. 10] == [-4,24,45,61,72,81,87,92,96,98,100] import Sound.Sc3.Plot plotTable (map (\c-> map (sc3_lincurve c 0 1 (-1) 1) [0,0.01 .. 1]) [-6,-4 .. 6])hsc3 Inverse of . let f = round . sc3_curvelin (-3) (-4.3) 100 0 10 in map f [-4,24,45,61,72,81,87,92,96,98,100] == [0..10]hsc3Removes all but the last trailing zero from floating point string.hsc3.The default show is odd, 0.05 shows as 5.0e-2. unwords (map (double_pp 4) [0.0001,0.001,0.01,0.1,1.0]) == "0.0001 0.001 0.01 0.1 1.0"hsc3+Print as integer if integral, else as real. unwords (map (real_pp 5) [0.0001,0.001,0.01,0.1,1.0]) == "0.0001 0.001 0.01 0.1 1"hsc3Type-specialised XY.hsc3>Non-specialised optimised sum function (3 & 4 element adders).hsc3'Taylor approximation of sin, (-pi, pi). import Sound.Sc3.Plot let xs = [-pi, -pi + 0.05 .. pi] in plot_p1_ln [map sin_taylor_approximation xs, map sin xs] let xs = [-pi, -pi + 0.05 .. pi] in plot_p1_ln [map (\x -> sin_taylor_approximation x - sin x) xs]hsc3'Bhaskara approximation of sin, (0, pi). import Sound.Sc3.Plot let xs = [0, 0.05 .. pi] in plot_p1_ln [map sin_bhaskara_approximation xs, map sin xs] let xs = [0, 0.05 .. pi] in plot_p1_ln [map (\x -> sin_bhaskara_approximation x - sin x) xs]hsc38Robin Green, robin_green@playstation.sony.com, (-pi, pi) import Sound.Sc3.Plot let xs = [-pi, -pi + 0.05 .. pi] in plot_p1_ln [map sin_green_approximation xs, map sin xs] let xs = [-pi, -pi + 0.05 .. pi] in plot_p1_ln [map (\x -> sin_green_approximation x - sin x) xs]hsc3Paul Adenot, (-pi, pi) import Sound.Sc3.Plot let xs = [-pi, -pi + 0.05 .. pi] in plot_p1_ln [map sin_adenot_approximation xs, map sin xs] let xs = [-pi, -pi + 0.05 .. pi] in plot_p1_ln [map (\x -> sin_adenot_approximation x - sin x) xs] Safe-InferredIhsc3z ranges from 0 (for i ) to 1 (for j). <> 1.5.blend(2.0,0.50) == 1.75 > 1.5.blend(2.0,0.75) == 1.875 2blend 0.50 1.5 2 == 1.75 blend 0.75 1.5 2 == 1.875hsc3 Variant of  but values for index greater than the size of the collection will be clipped to the last index. 2map (\x -> clipAt x "abc") [-1,0,1,2,3] == "aabcc"hsc3 with clip function as argument.hsc3SequenceableCollection.blendAt returns a linearly interpolated value between the two closest indices. Inverse operation is indexInBetween. > [2,5,6].blendAt(0.4) == 3.2 1blendAt 0 [2,5,6] == 2 blendAt 0.4 [2,5,6] == 3.2hsc3Resampling function, n is destination length, r is source length, f is the indexing function, c is the collection.hsc3SequenceableCollection.resamp1 returns a new collection of the desired length, with values resampled evenly-spaced from the receiver with linear interpolation. > [1].resamp1(3) == [1,1,1] > [1,2,3,4].resamp1(12) > [1,2,3,4].resamp1(3) == [1,2.5,4] resamp1 3 [1] == [1,1,1] resamp1 12 [1,2,3,4] resamp1 3 [1,2,3,4] == [1,2.5,4]hsc3ArrayedCollection.normalizeSum ensures sum of elements is one. > [1,2,3].normalizeSum == [1/6,1/3,0.5] normalizeSum [1,2,3] == [1/6,2/6,3/6]hsc3:Variant that specifies range of input sequence separately.hsc3ArrayedCollection.normalize returns a new Array with the receiver items normalized between min and max. > [1,2,3].normalize == [0,0.5,1] > [1,2,3].normalize(-20,10) == [-20,-5,10] normalize 0 1 [1,2,3] == [0,0.5,1] normalize (-20) 10 [1,2,3] == [-20,-5,10]hsc32List of 2-tuples of elements at distance (stride) n. )t2_window 3 [1..9] == [(1,2),(4,5),(7,8)]hsc3&List of 2-tuples of adjacent elements. t2_adjacent [1..6] == [(1,2),(3,4),(5,6)] t2_adjacent [1..5] == [(1,2),(3,4)]hsc3)List of 2-tuples of overlapping elements. (t2_overlap [1..4] == [(1,2),(2,3),(3,4)]hsc3Concat of 2-tuples. t2_concat (t2_adjacent [1..6]) == [1..6] t2_concat (t2_overlap [1..4]) == [1,2,2,3,3,4]hsc3A Signal is half the size of a Wavetable, each element is the sum of two adjacent elements of the Wavetable. from_wavetable [-0.5,0.5,0,0.5,1.5,-0.5,1,-0.5] == [0.0,0.5,1.0,0.5] let s = [0,0.5,1,0.5] in from_wavetable (to_wavetable s) == shsc3A Wavetable has n * 2 + 2 elements, where n is the number of elements of the Signal. Each signal element e0 expands to the two elements (2 * e0 - e1, e1 - e0) where e1 is the next element, or zero at the final element. Properly wavetables are only of power of two element signals. > Signal[0,0.5,1,0.5].asWavetable == Wavetable[-0.5,0.5,0,0.5,1.5,-0.5,1,-0.5] to_wavetable [0,0.5,1,0.5] == [-0.5,0.5,0,0.5,1.5,-0.5,1,-0.5]hsc3(Shaper requires wavetables without wrap. >to_wavetable_nowrap [0,0.5,1,0.5] == [-0.5,0.5,0,0.5,1.5,-0.5]hsc3 Variant of ! that gives each component table. let t = sineGen 1024 (map recip [1, 2, 3, 5, 8, 13, 21, 34, 55]) (replicate 9 0) map length t == replicate 9 1024 Sound.Sc3.Plot.plot_p1_ln thsc3Signal.*sineFill is a table generator. Frequencies are partials, amplitudes and initial phases are as given. Result is normalised. let a = [[21,5,34,3,2,13,1,8,55],[13,8,55,34,5,21,3,1,2],[55,34,1,3,2,13,5,8,21]] let t = map (\amp -> sineFill 1024 (map recip amp) (replicate 9 0)) a Sound.Sc3.Plot.plot_p1_ln t  Safe-Inferredhsc3.hsc3 of . Sound.Sc3.Common.Buffer.Vector.blendAt 0 (V.fromList [2,5,6]) == 2 Sound.Sc3.Common.Buffer.Vector.blendAt 0.4 (V.fromList [2,5,6]) == 3.2 Sound.Sc3.Common.Buffer.Vector.blendAt 2.1 (V.fromList [2,5,6]) == 6hsc3 Sound.Sc3.Common.Buffer.Vector.from_wavetable (V.fromList [-0.5,0.5,0,0.5,1.5,-0.5,1,-0.5])hsc3. Sound.Sc3.Common.Buffer.Vector.resamp1 12 (V.fromList [1,2,3,4]) Sound.Sc3.Common.Buffer.Vector.resamp1 3 (V.fromList [1,2,3,4]) == V.fromList [1,2.5,4]  Safe-InferredZhsc3#Sum (mix) multiple tables into one.hsc3Unit normalisation.hsc3 with zero phase. import Sound.Sc3.Plot {- hsc3-plot -} plot_p1_ln [sine1_p 512 (1, 1)]hsc39Series of sine wave harmonics using specified amplitudes.hsc3 of . 'plot_p1_ln [sine1 256 [1, 0.95 .. 0.5]]hsc3 of . Sound.Sc3.Plot.plot_p1_ln [sine1_nrm 256 [1, 0.95 .. 0.5]] Sound.Sc3.Plot.plot_p1_ln [sine1_nrm 256 [1, 1/2, 1/3, 1/4, 1/5]]hsc3Variant that generates a wavetable (without guard point) suitable for the Shaper Ugen.hsc3 Series of n? sine wave partials using specified frequencies and amplitudes.hsc3 of . Sound.Sc3.Plot.plot_p1_ln [sine2 256 (zip [1, 2..] [1, 0.95 .. 0.5])] Sound.Sc3.Plot.plot_p1_ln [sine2 256 (zip [1, 1.5 ..] [1, 0.95 .. 0.5])]hsc3 of .hsc3 map (curve c (-1) 1) [0,0.01 .. 1]) [-6,-4 .. 6]) plot_p1_ln (map (\f -> map f [0,0.01 .. 1]) [curve 4.4 1 100,exponential 1 100,curve 4.5 1 100]) plot_p1_ln (map (\f -> map f [0,0.01 .. 1]) [exponential 20 20000,curve 7 20 20000]) plot_p1_ln (map (\f -> map f [0,0.01 .. 1]) [fader 0 2,curve 2 0 2])hsc3 Square of  of 1 of x0 and x1, therefore neither may be negative. plot_fn_r1_ln (squared 0 1) (0,1) plot_p1_ln (map (\f -> map f [0,0.01 .. 1]) [curve 2.05 0 1,squared 0 1])hsc3Cubic variant of . plot_fn_r1_ln (cubed 0 1) (0,1) plot_p1_ln (map (\f -> map f [0,0.01 .. 1]) [curve 3.25 0 1,cubed 0 1])hsc3"x0 until end, then immediately x1. plot_fn_r1_ln (hold 0 1) (0,2)hsc3Fader curve, equal to  when x1 > x0. plot_p1_ln (map (\f -> map f [0,0.01 .. 1]) [squared 0 1,fader 0 1]) plot_p1_ln (map (\f -> map f [0,0.01 .. 1]) [curve 2 1 0,fader 1 0]) Safe-Inferred]hsc3Parameters for Asr envelopes.hsc3+Parameters for Roland type Adssr envelopes.hsc3Parameters for Adsr envelopes. The sustain level is given as a proportion of the peak level.hsc3Parameters for Linen envelopes.hsc3A set of start time, start level, end time, end level and curve.hsc3Sc3 envelope segment modelhsc3Set of n levels, n is >= 1hsc3Set of n-1 time intervalshsc3Possibly empty curve sethsc3Maybe index to release nodehsc3Maybe index to loop nodehsc3,An offset for all time values (IEnvGen only)hsc3Envelope curve quadruple.hsc3Envelope curve triple.hsc3Envelope curve pair.hsc3Envelope curve indicator input.hsc3Note: not implemented at Sc3hsc3Convert  to shape value. ,map env_curve_shape [EnvSin,EnvSqr] == [3,6]hsc3The value of EnvCurve is non-zero for . 0map env_curve_value [EnvWelch,EnvNum 2] == [0,2]hsc3Interpolation_f of .hsc3Apply f to  value.hsc3Apply f to all a at .hsc3Variant without release and loop node inputs (defaulting to nil). Sound.Sc3.Plot.plotEnvelope [envelope [0,1,0] [3,2] [EnvSin,EnvSin]]hsc3 Duration of , ie.   .hsc3Number of segments at , ie.   .hsc3.Determine which envelope segment a given time t falls in.hsc3(Extract envelope segment given at index i.hsc3Extract all segments.hsc3Transform list of s into lists (,,).hsc3An envelope is normal* if it has no segments with zero duration.hsc39Normalise envelope by deleting segments of zero duration.hsc3Get value for  at time t , or zero if t is out of range. By convention if the envelope has a segment of zero duration we give the rightmost value.hsc3Render  to breakpoint set of n equi-distant places.hsc3Contruct a lookup table of n places from .hsc3 Variant on  that expands the, possibly empty, user list by cycling (if not empty) or by filling with .hsc3Linear Sc3 form of  data.*Form is: l0 #t reset loop l1 t0 c0 c0' ...envelope_sc3_array (envelope [0,1] [0.1] [EnvLin]) == Just [0,1,-99,-99,1,0.1,1,0] let l = [0,0.6,0.3,1.0,0] let t = [0.1,0.02,0.4,1.1] let c = [EnvLin,EnvExp,EnvNum (-6),EnvSin] let e = Envelope l t c Nothing Nothing 0 let r = [0,4,-99,-99,0.6,0.1,1,0,0.3,0.02,2,0,1,0.4,5,-6,0,1.1,3,0] envelope_sc3_array e == Just rhsc3IEnvGen Sc3 form of  data. l = [0,0.6,0.3,1.0,0] t = [0.1,0.02,0.4,1.1] c = [EnvLin,EnvExp,EnvNum (-6),EnvSin] e = Envelope l t c Nothing Nothing 0 r = [0,0,4,1.62,0.1,1,0,0.6,0.02,2,0,0.3,0.4,5,-6,1,1.1,3,0,0] envelope_sc3_ienvgen_array e == Just rhsc3 if  is not .hsc36Delay the onset of the envelope (add initial segment).hsc3Connect releaseNode (or end) to first node of envelope. z is a value that is first zero and thereafter one. tc & cc are time and curve from first to last.hsc3%env_circle_z with cycle time of zero.hsc3Trapezoidal envelope generator. Requires ( =)and (=) functions returning 1 for true and 0 for false.The arguments are: 1. shape0 determines the sustain time as a proportion of dur, zero is a triangular envelope, one a rectangular envelope; 2. skew determines the attack/decay ratio, zero is an immediate attack and a slow decay, one a slow attack and an immediate decay; 3. duration in seconds; 4.  amplitude as linear gain.hsc3Coordinate based static envelope generator. Points are (time,value) pairs. let e = envCoord [(0,0),(1/4,1),(1,0)] 1 1 EnvLin envelope_sc3_array e == Just [0,2,-99,-99,1,1/4,1,0,0,3/4,1,0] import Sound.Sc3.Plot plotEnvelope [envCoord [(0,0),(1/4,1),(1,0)] 1 1 EnvLin]hsc3Segments given as pairs of (time,level). The input is sorted by time before processing. .envPairs [(0, 1), (3, 1.4), (2.1, 0.5)] EnvSinhsc3Percussive envelope, with attack, release, level and curve inputs.hsc34Percussive envelope, with attack and release inputs.hsc34Triangular envelope, with duration and level inputs. let e = envTriangle 1 0.1 envelope_sc3_array e == Just [0,2,-99,-99,0.1,0.5,1,0,0,0.5,1,0]hsc3.Sine envelope, with duration and level inputs. let e = envSine 0 0.1 envelope_sc3_array e == Just [0,2,-99,-99,0.1,0.5,1,0,0,0.5,1,0]hsc3Sc3 defaults for Linen.hsc3Record ( ) variant of .hsc3 Variant of ( with user specified 'Envelope_Curve a'.hsc3&Linear envelope parameter constructor. e = envLinen 0 1 0 1 s = envelope_segments e p = pack_envelope_segments s p == (env_levels e,env_times e,env_curves e)hsc3Sc3 defaults for Adsr.hsc3?Attack, decay, sustain, release envelope parameter constructor.hsc3&Variant with defaults for pL, c and b.hsc3Record ( ) variant of .hsc3Attack, decay, slope, sustain, release envelope parameter constructor.hsc3Record ( ) variant of .hsc3Sc3 default values for Asr.hsc36Sc3 .asr has singular curve argument, hence _c suffix.hsc38Attack, sustain, release envelope parameter constructor. c = 3 r = Just [0,2,1,-99,0.1,3,c,0,0,2,c,0] envelope_sc3_array (envAsr 3 0.1 2 EnvSin) == rhsc3Record ( ) variant of .hsc3"All segments are horizontal lines.hsc3Segments given as triples of (time,level,curve). The final curve is ignored. =envXyc [(0, 1, EnvSin), (2.1, 0.5, EnvLin), (3, 1.4, EnvLin)]hsc3x' = s * (y - x) y' = x * (r - z) - y z' = x * y - b * zhsc3"x(n+1) = a * x(n)^2 + b * x(n) + chsc3x(n+1) = (x(n) + y(n+1)) % 2pi y(n+1) = (y(n) + k * sin(x(n))) % 2pi   Safe-Inferredhsc3Sc3_Binary_Op operator class.hsc3Unary operator class. map (floor . (* 1e4) . dbAmp) [-90,-60,-30,0] == [0,10,316,10000]hsc3 Variant of  with non  results.hsc3Variant on Ord class, result is of the same type as the values compared.hsc3 Variant on : class, result is of the same type as the values compared.hsc3Enumeration of Sc3 unary operator Ugens. The names here are from the enumeration at "serverpluginsBinaryOpUgens.cpp".  (x,binaryIndex Ci x)) (map snd binary_sym_tbl)hsc3 of . -map (is_binary Ci) (words "== > % Trunc max")hsc38Lookup operator name for operator Ugens, else Ugen name.hsc3#Order of lookup: binary then unary. map (resolve_operator Ci) (words "+ - Add sub Neg abs") map (resolve_operator Cs) (words "Abs")hsc3"Case-insensitive resolve_operator.hsc3Association table for + to haskell function implementing operator.hsc3  via .hsc3Association table for Unary+ to haskell function implementing operator.hsc3  via . Safe-Inferred hsc3'A warp function is lhs -> rhs -> x -> yhsc3Linear real value map. map (warp_lin 1 2) [0,1/2,1] == [1,3/2,2] map (warp_lin (-1) 1) [0,1/2,1] == [-1,0,1]hsc3 Inverse of  map (warp_lin_inv 1 2) [1,3/2,2] == [0,1/2,1] map (warp_lin_inv (-1) 1) [-1,0,1] == [0,1/2,1]hsc3The left and right must both be non zero and have the same sign. map (warp_exp 1 2) [0,0.5,1] == [1,2 ** 0.5,2] import Sound.Sc3.Plot plot_p1_ln [map (warp_exp 1 2) [0,0.01 .. 1]]hsc3 Cosine warp map (warp_cos 1 2) [0,0.25,0.5,0.75,1] plot_p1_ln [map (warp_cos 1 2) [0,0.01 .. 1]]hsc3 Sine warp map (warp_sin 1 2) [0,0.25,0.5,0.75,1] plot_p1_ln [map (warp_sin 1 2) [0,0.01 .. 1]]hsc3?Fader warp. Left and right values are ordinarily zero and one. *map (warp_amp 0 1) [0,0.5,1] == [0,0.25,1] plot_p1_ln [map (warp_amp 0 2) [0,0.01 .. 1]] plot_p1_ln [map (warp_amp_inv 0 1 . warp_amp 0 1) [0,0.01 .. 1]]hsc3DB fader warp. Left and right values are ordinarily negative infinity and zero. An input of 0 gives -180. 8map (round . warp_db (-180) 0) [0,0.5,1] == [-180,-12,0] plot_p1_ln [map (warp_db (-60) 0) [0,0.01 .. 1]] plot_p1_ln [map (warp_db_inv 0 60) [0 .. 60]]hsc3A curve warp given by a real n. warp_curve (-3) 1 2 0.25 == 1.5552791692202022 warp_curve (-3) 1 2 0.50 == 1.8175744761936437 plot_p1_ln [map (warp_curve (-3) 1 2) [0,0.01 .. 1]] plot_p1_ln (map (\c -> map (warp_curve c 1 2) [0,0.01 .. 1]) [0,3,6,9]) plot_p1_ln [map (warp_curve_inv 7 20 20000 . warp_curve 7 20 20000) [0,0.01 .. 1]]hsc3Select warp functions by name. Numerical names are interpreted as curve values for  warpCurve. let Just w = warp_named "lin" let Just w = warp_named "-3" let Just w = warp_named "6" plot_p1_ln [map ((fst w) 1 2) [0,0.01 .. 1]] Safe-Inferred;hsc3Format for table. Closed indicates the end point should be equal to the start point. Open indicates it should be one place short. Guarded indicates that an extra place should be added that closes the table, ie. the table has one place more than requested. When using a table with an oscillator we want an Open or Guarded table, since the point following the end point is the start point.hsc3A discrete rendering of a .hsc37A function from a (0, 1) normalised input to an output.hsc3 Generate an n8 element table from a (0, 1) normalised window function f. The cycle argument decides if the end point should be equal to the start point, or one place short. When using a table with an oscillator we want the latter, since the point following the end point is the start point.hsc3window_table of TableClosed.hsc3n ^ 2.hsc3Gaussian window,  <= 0.5.hsc3Hann raised cosine window.hsc3Hamming raised cosine window.hsc3Unit (+) window, also known as a Dirichlet window.hsc3 window.hsc3 window_table fmt n triangular) [TableClosed, TableOpen]) Sound.Sc3.Plot.plot_p1_ln (map (\fmt -> window_table fmt n triangular) [TableClosed, TableGuarded])hsc3 . . Sound.Sc3.Plot.plot_p1_ln [gaussian_table 1024 0.25, gaussian_table 1024 0.5]hsc3 . . =Sound.Sc3.Plot.plot_p1_ln [hann_table 128, hamming_table 128]hsc3 . . .Sound.Sc3.Plot.plot_p1_ln [hann_table (2 ^ 7)]hsc3 . . .Sound.Sc3.Plot.plot_p1_ln [sine_table (2 ^ 7)]hsc3 . . 4Sound.Sc3.Plot.plot_p1_ln [triangular_table (2 ^ 8)] Safe-Inferred hsc3Multiple channel expansion. The Mce type is a tree, however in hsc3 Mce_Vector will always hold Mce_Scalar elements.hsc3There are two invariants: 1. Mce should not be empty, ie. Mce_Vector should not have a null list. 2. Scalar Mce values should not be written as one-place vectors. mce_is_well_formed (Mce_Vector []) == False mce_is_well_formed (Mce_Vector [Mce_Scalar 1]) == Falsehsc3Is Mce scalar.hsc3,fromList for Mce, generates well-formed Mce.hsc3toList for Mce. let v = Mce_Vector in mce_to_list (v[v[1, 2], 3, v[4, 5]]) == [1, 2, 3, 4, 5]hsc3Pretty printer for Mce. let v = Mce_Vector in mce_show (v[1, 2, v[3, 4]] * 5 + v[6, 7, 8]) == "[11, 17, [23, 28]]"hsc36Read value from Mce_Scalar, error if Mce is Mce_Vectorhsc3Length, or perhaps rather width, of Mce. Considers only the outermost level, i.e. mce_length is not necessarily the length of mce_to_list.hsc3The depth of an Mce is the longest sequence of nested Mce_Vector nodes. mce_depth 1 == 1 mce_depth (Mce_Vector [1, 2]) == 1 let v = Mce_Vector in mce_depth (v[v[1, 2], 3, v[4, 5]]) == 2 let v = Mce_Vector in mce_depth (v[v[1, 2, 3, v[4, 5], 6], 7]) == 3hsc3Extend Mce to specified degree. Considers only the outermost level.hsc3fmap for Mce, apply f at elements of m.hsc3Apply f pairwise at elements of m1 and m2. At each level this extends the shorter of the two operands. Safe-Inferredhsc3 of hsc3This is the same function as Control.Monad.void, which however hugs does not know of.hsc3void of .hsc3Right to left compositon of  functions. fmap (== 7) (composeM [return . (+ 1),return . (* 2)] 3) fmap (== 8) (composeM [return . (* 2),return . (+ 1)] 3)hsc3Feed forward composition of n applications of f. )fmap (== 3) (chainM 3 (return . (+ 1)) 0) Safe-Inferred hsc3 variant with  at left. /fmap (== 5) (return 3 .+ 2) [3,4] .+ 2 == [5,6]hsc3 variant with  at right. /fmap (== 5) (3 +. return 2) 3 +. [2,3] == [5,6]hsc3 variant with  at left and right. fmap (== 5) (return 3 .+. return 2) [3,4] .+. [2,3] == [5,6,6,7] getZipList (ZipList [3,4] .+. ZipList [2,3]) == [5,7]hsc3 variant with  at left. fmap (== 6) (return 3 .* 2)hsc3 variant with  at right. fmap (== 6) (3 *. return 2)hsc3 variant with  at left and right. #fmap (== 6) (return 3 .*. return 2)hsc3 variant with  at left. /fmap (== 1) (return 3 .- 2) [3,4] .- 2 == [1,2]hsc3 variant with  at right. /fmap (== 1) (3 -. return 2) 3 -. [2,3] == [1,0]hsc3 variant with  at left and right. fmap (== 1) (return 3 .-. return 2) [3,4] .-. [2,3] == [1,0,2,1] getZipList (ZipList [3,4] .-. ZipList [2,3]) == [1,1]hsc3 variant with  at left. fmap (== 3) (return 6 ./ 2)hsc3 variant with  at right. fmap (== 3) (6 /. return 2)hsc3 variant with  at left and right. fmap (== 3) (return 6 ./. return 2) [5,6] ./. [2,3] == [5/2,5/3,3,2]   666777666777 Safe-Inferredphsc3=Linear congruential generator given modulo function for type.See  :http://en.wikipedia.org/wiki/Linear_congruential_generator for possible parameters.hsc3 6364136223846793005 1442695040888963407, so in (0, 18446744073709551615) take 5 (iterate lcgWord64Knuth 147092873413) (maxBound :: Word64) == (2 ^ 64 - 1)hsc32 1103515245 12345, so in (-2147483648, 2147483647) take 5 (iterate lcgInt32Glibc 873413) (minBound :: Int32,maxBound :: Int32) == (-2147483648, 2147483647)hsc3$Run getCPUTime and convert to Word64hsc3#Run getCPUTime and convert to Int32hsc3/Iterate lcgWord64Knuth using cpuTimeSeedWord64.hsc3Convert Word64 to Double in range (0, 1). Shifts input right 11 places (ie. discards 11 least significant bits) then divide by 2^53.hsc3+word64ToUnitDouble of lcgWord64KnuthCpuTime x <- fmap (take 256) lcgDoubleKnuthCpuTime Sound.Sc3.Plot.plot_p1_ln [x] Safe-Inferred : hsc3Enumeration of the four operating rates for controls. I = initialisation, K = control, T = trigger, A = audio.hsc32Enumeration of operating rates of unit generators.hsc3Standard abbreviations of Rate values. ir = initialisation, kr = control, ar = audio, dr = demand. dr sorts to the right of the fixed clock rates. -Data.List.sort [dr,ar,kr,ir] == [ir,kr,ar,dr]hsc3Standard abbreviations of Rate values. ir = initialisation, kr = control, ar = audio, dr = demand. dr sorts to the right of the fixed clock rates. -Data.List.sort [dr,ar,kr,ir] == [ir,kr,ar,dr]hsc3Standard abbreviations of Rate values. ir = initialisation, kr = control, ar = audio, dr = demand. dr sorts to the right of the fixed clock rates. -Data.List.sort [dr,ar,kr,ir] == [ir,kr,ar,dr]hsc3Standard abbreviations of Rate values. ir = initialisation, kr = control, ar = audio, dr = demand. dr sorts to the right of the fixed clock rates. -Data.List.sort [dr,ar,kr,ir] == [ir,kr,ar,dr]hsc3*Standard SuperCollider rate abbreviations. >map rateAbbrev [minBound .. maxBound] == ["ir","kr","ar","dr"]hsc3*Standard SuperCollider rate abbreviations. map rateName [minBound .. maxBound] == ["scalar","control","audio","demand"]hsc3:Integer rate identifier, as required for scsynth bytecode.hsc3Color identifiers for each .hsc3 Set of all  values.hsc3!Case insensitive parser for rate. Data.Maybe.mapMaybe rate_parse (words "ar kR IR Dr") == [AudioRate,ControlRate,InitialisationRate,DemandRate]hsc3!Determine class of control given  and trigger status. Safe-Inferredo hsc3Find the file fn (case-sensitively) starting from dir. Runs the system command "find" (so UNIX only). Note that fn must be a file name not a relative path name. :findFileFromDirectory "/home/rohan/data/audio" "metal.wav"hsc3Find the file fn starting from dir. If dir/fn names a file return that file, else call findFileFromDirectory. Note this will not find dirpq r given qr, the query must be either pqr or r. findFileAtOrFromDirectory "/home/rohan/data/audio" "instr/bosendorfer/072/C5.aif"hsc3Run findFileAtOrFromDirectory for each entry in path until the file is found, or not. ?findFileAtOrFromPath ["/home/rohan/rd/data/"] "20.2-LW+RD.flac"hsc3SFDIR environment variable.hsc3SFPATH environment variable.hsc3Find file fn at  directly or along . If fn is either absolute or names a relative file and if that file exists it is returned. If sdDir/fn exists it is returned. Else each directory at sfPath is searched (recursively) in turn. Despite the name this will find any file type along the SFDIR and SFPATH, i.e. .sfz files &etc. mapM sfFindFile ["/home/rohan/data/audio/metal.wav", "pf-c5.aif", "20.2-LW+RD.flac"]hsc3sfFindFile or error.hsc3Unsafe sfResolveFile. For resolving sound file names at read only sound file archives this is quite safe.hsc3Return the number of channels at fn. Runs the system command "soxi" (so UNIX only). 5sfResolveFile "metal.wav" >>= sfNumChannels >>= printhsc3Return the sample rate of fn. Runs the system command "soxi" (so UNIX only). 4sfResolveFile "metal.wav" >>= sfSampleRate >>= printhsc3Return the number of frames at fn. Runs the system command "soxi" (so UNIX only). 4sfResolveFile "metal.wav" >>= sfFrameCount >>= printhsc3Return the number of channels, sample-rate and number of frames at fn. Runs the system command "soxi" (so UNIX only). 2sfResolveFile "metal.wav" >>= sfMetadata >>= printhsc3Unsafe sfMetadata. For fetching sound file information from read only sound file archives this is quite safe. sfInfo (sfResolve "metal.wav") == (1,44100,1029664) sfInfo (sfResolve "pf-c5.aif") == (2,44100,576377)   Safe-Inferredhsc3Typeclass to constrain Ugen identifiers. Char inputs are hashed to generate longer seeds for when ir (constant) random Ugens are optimised. map resolveID [0::Int,1] == [0, 1] map resolveID ['', ''] == [1439603815, 4131151318] map resolveID [('', ''),('', '')] == [3538183581, 3750624898] map resolveID [('',('', '')),('',('', ''))] == [0020082907, 2688286317] map resolveID [('', '', ''),('', '', '')] == [0020082907, 2688286317]hsc3 Uid.hsc3A class indicating a monad (and functor and applicative) that will generate a sequence of unique integer identifiers.hsc3Identifiers are integers.hsc3 Alias for .hsc3 with initial state of zero. 3uid_st_eval (replicateM 3 generateUid) == [0, 1, 2]hsc3!Thread state through sequence of .hsc3 of . 2uid_st_seq_ (replicate 3 generateUid) == [0, 1, 2]hsc3Unary Uid lift.hsc3Binary Uid lift.hsc3Ternary Uid lift.hsc3Quaternary Uid lift.hsc35-parameter Uid lift.hsc36-parameter Uid lift.hsc310-parameter Uid lift.hsc311-parameter Uid lift.hsc3n identifiers from x. +id_seq 10 '' == [1439603815 .. 1439603824]hsc3Requires FlexibleInstances.] Safe-Inferredh=?>@CABDIHGEFJNMKLORQPSTUVWXYghijklmnopqrstuvwxyz{|} Safe-Inferred" hsc3Lift monadic r to unsafe form.hsc3Lift monadic r to unsafe form.hsc3Lift monadic r to unsafe form.hsc3Lift monadic r to unsafe form.hsc3Lift monadic r to unsafe form.hsc3Lift monadic r to unsafe form.hsc3Lift monadic r to unsafe form.hsc3Lift monadic r to unsafe form.hsc3Lift monadic r to unsafe form.hsc3Lift monadic r to unsafe form.hsc3Lift monadic r to unsafe form.hsc3Lift monadic r to unsafe form.hsc3Lift monadic r to unsafe form.   Safe-Inferred&E hsc3 SC3 server commands are strings.hsc3!Enumerate server command numbers.hsc3Lookup command number in . . Supports version 0|1 and version 2 files. Ignores variants.hsc3Simple statistics printer for .hsc37Pretty print Ugen in the manner of SynthDef>>dumpUgens.hsc3Print graphdef in format equivalent to SynthDef>>dumpUgens in SuperColliderhsc3 of  of  import Sound.Sc3.Server.Graphdef dir = "/home/rohan/sw/rsc3-disassembler/scsyndef/" pp nm = read_graphdef_file (dir ++ nm) >>= graphdef_dump_ugens pp "simple.scsyndef" pp "with-ctl.scsyndef" pp "mce.scsyndef" pp "mrg.scsyndef".. Safe-Inferred7N hsc3Get a  (Pascal string).hsc3)Get_Functions for binary .scsyndef files.hsc3"Read Graphdef from .scsyndef file. dir = "/home/rohan/sw/rsc3-disassembler/scsyndef/" pp nm = read_graphdef_file (dir ++ nm) >>= putStrLn . graphdef_stat pp "simple.scsyndef" pp "with-ctl.scsyndef" pp "mce.scsyndef" pp "mrg.scsyndef"hsc3 and run .hsc3 for hsc3%Pascal (length prefixed) encoding of . L.unpack (encode_pstr (ascii "string")) == [6, 115, 116, 114, 105, 110, 103]hsc3 Byte-encode .hsc3 Byte-encode .hsc3 Byte-encode .hsc3Encode  as 32-bit IEEE float.hsc3Encode .hsc3Write  to indicated file.hsc3Write / to indicated directory. The filename is the ! with the appropriate extension (scsyndef).    Safe-Inferred;hsc3PrinterPrint string. Strings must not have internal whitespace or semi-colons. A quoting system could allow these if required.hsc3 for plain text output.hsc3 of - with optional semi-colon delimited comments. import Sound.Sc3.Server.Graphdef.Binary dir = "/home/rohan/sw/rsc3-disassembler/scsyndef/" pp nm = read_graphdef_file (dir ++ nm) >>= putStrLn . print_graphdef True pp "simple.scsyndef" pp "with-ctl.scsyndef" pp "mce.scsyndef" pp "mrg.scsyndef"hsc3 Read the next value from a list.hsc3>Read function for floating point that admits inf and infinity.hsc32Get_Functions for text representation of Graphdef.hsc34Read text representation of Graphdef, as written by . read_graphdef "1396926310 0 1 simple 2 0.0 440.0 0 0 2 SinOsc 2 2 1 0 -1 1 -1 0 2 Out 2 2 0 0 -1 0 0 0"! Safe-Inferred<hsc3Encoding agnostic file reader. If the file has a .scsyndef.text extension it's read as a text file, else as a binary file.read_graphdef_file "tmpstsc3.scsyndef.text"" Safe-Inferred? hsc3An  score is a sequence of s.hsc3-Encode Bundle and prefix with encoded length.hsc3 of f of #. Can be used to separate the initialisation and  remainder parts of a score.hsc3 Encode an  score.hsc3 Write an  score. import Sound.Osc import Sound.Sc3 m1 = g_new [(1, AddToTail, 0)] m2 = d_recv (synthdef "sin" (out 0 (sinOsc ar 660 0 * 0.15))) m3 = s_new "sin" 100 AddToTail 1 [] m4 = n_free [100] m5 = nrt_end sc = Nrt [bundle 0 [m1,m2],bundle 1 [m3],bundle 10 [m4],bundle 15 [m5]] writeNrt "/tmp/t.osc" schsc3 Write an  score to a file handle.hsc3 Decode an   to a list of s.hsc3 Decode an  .hsc3 of . readNrt "/tmp/t.osc"hsc3!Find any non-ascending sequences.  # Safe-InferredDOhsc3Variant for no input case.(osc-file-name, audio-file-name, number-of-channels, sample-rate, sample-format, param)hsc3!Minimal Nrt rendering parameters.The sound file type is inferred from the file name extension. Structure is: Osc file name, input audio file name and input number of channels (use ("_",0) for no input file), output audio file name and output number of channels, sample rate (int), sample format, further parameters (ie. ["-m","32768"]) to be inserted before the Nrt -N option.hsc3+Compile argument list from Nrt_Param_Plain. let opt = ("/tmp/t.osc",("_",0),("/tmp/t.wav",1),48000,PcmInt16,[]) let r = ["-i","0","-o","1","-N","/tmp/t.osc","_","/tmp/t.wav","48000","wav","int16"] nrt_param_plain_to_arg opt == rhsc3:Compile argument list from Nrt_Param_Plain and run scynth. nrt_exec_plain opthsc3>Minimal Nrt rendering, for more control see Stefan Kersten's  hsc3-process package at:  ,https://github.com/kaoskorobase/hsc3-process.hsc3(Add ("-",0) as input parameters and run . nrt_render_plain opt sc$ Safe-InferredEhsc30Nrt statistics, see nrt_stat_param for meanings.hsc3Nrt_Stat names.hsc3Trivial Nrt statistics.% Safe-InferredHhsc3Protocol is either Udp or Tcp.hsc3*(short-option, long-option, default-value)hsc3Get value from option.hsc3Default address string.hsc3Default port number, either a u or a t option is required.hsc3Default port option.hsc3SC3 default options.hsc3SC3 default options for Udp.hsc3*Is option boolean, ie. 0=FALSE and 1=TRUE. #filter sc3_opt_bool sc3_opt_def_udphsc3.Lookup option given either short or long name.hsc3+Set option given either short or long name. *sc3_opt_set sc3_opt_def_udp (Left 'w',256)hsc3Apply set of edits to options. ?sc3_opt_edit sc3_opt_def_udp [(Left 'w',256),(Left 'm',2 ^ 16)]hsc3Generate scsynth argument list. %unwords (sc3_opt_arg sc3_opt_def_udp)hsc3Generate arguments for ^_ or related functions. sc3_opt_cmd sc3_opt_def_udp& Safe-InferredL hsc3"Set of Sc3 synthesiser parameters.hsc3 Constant 1) == True) Safe-InferredThsc3Control inputs. It is an unchecked invariant that controls with equal names within a Ugen graph must be equal in all other respects.hsc35-tuple form of  data.hsc33-tuple form of  data.hsc3Control meta-data.hsc3Minimumhsc3Maximumhsc3(0,1)  (min,max) transfer function.hsc3%The step to increment & decrement by.hsc3!Unit of measure (ie hz, ms etc.).hsc3Control group.hsc3Controls may form part of a control group. There are presently three types of groups. Ranges controls have two values (minima, maxima) and are ordinarily drawn as a range slider. Array controls have n values [e1 .. eN] and are ordinarily drawn as a multislider. Xy controls have two values (x, y) and are ordinarily drawn as a two dimensional slider.hsc3*The number of elements in a control group.hsc3Grouped controls have names that have equal prefixes and identifying suffixes. Range controls have two elements, minima and maxima, suffixes are [ and ]. Array controls have n elements and have zero-indexed numerical suffixes. Xy controls have two elements, X and Y coordinates, suffixes are X and Y.hsc3Lift  to  allowing type coercion.hsc3Lift  to  allowing type coercion.* Safe-InferredZhsc3T = tuple (see Base for T2-T4)hsc3 U = uniformhsc3F = function, ST = statehsc3 avg = averagehsc3fir = finite impulse response l_apply_f_st1 (fir1 (\x z1 -> (x + z1) / 2)) 0 [0 .. 5] == [0.0,0.5,1.5,2.5,3.5,4.5]hsc3fir = finite impulse response l_apply_f_st1 (fir2 (\x x1 x2 -> (x + x1 + x2) / 2)) (0,0) [0 .. 5] == [0.0,0.5,1.5,3.0,4.5,6.0]hsc3iir = infinite impulse response l_apply_f_st1 (iir1 (\x y1 -> x + y1)) 0 (replicate 10 1) == [1,2,3,4,5,6,7,8,9,10]hsc3!ff = feed-forward, fb = feed-backhsc3sos = second order sectionhsc3hp = high passhsc3 lp = low passhsc3bp = band passhsc3br = band rejecthsc3mavg = moving averagehsc3-Sample rate (SR) to radians per sample (RPS). )sr_to_rps 44100 == 0.00014247585730565955hsc3+resonz iir2_ff_fb function. param are for .hsc3ir = initialization ratehsc3rlpf = resonant low pass filterhsc3 "http://musicdsp.org/files/pink.txthsc3 "http://musicdsp.org/files/pink.txthsc3dt must not be zero.hsc3 Given time dt in frames construct  " function. dt must not be zero.hsc3 with dt in seconds.hsc3LIST PROCESSING+ Safe-Inferred[, Safe-Inferred\(  - Safe-Inferredb( hsc3Find all Sc3 name edges. Edges occur at non lower-case letters. This rule is very simple but is coherent and predictable and works well for .hs names. hsc3 Find non-initial Sc3 name edges. sc3_name_edges "SinOsc" == [False,False,False,True,False,False] sc3_name_edges "FFT" == [False,False,False] sc3_name_edges "DFM1" == [False,False,False,False] sc3_name_edges "PV_Add" == [False,False,False,True,False,False] sc3_name_edges "A2K" == [False,False,False] sc3_name_edges "Lag2UD" == [False,False,False,True,True,True] sc3_name_edges "PeakEQ" == [False,False,False,False,True,True] hsc3 hsc3#Union type of Unit Generator forms. hsc3Sc3 samples are 32-bit . hsc3 uses 64-bit . If  5 values are used more generally (ie. see hsc3-forth) 9 may be too imprecise, i.e. for representing time stamps. hsc38Lookup operator name for operator Ugens, else Ugen name. hsc3  form or . hsc3  of  parse_double. hsc3 See into  . hsc3 Value of   . hsc3Erroring variant. hsc3 Multiple root graph constructor. hsc3 See into  7, follows leftmost rule until arriving at non-Mrg node. hsc3Constant node predicate. hsc3True if input is a sink  %, ie. has no outputs. Sees into Mrg. hsc3 See into  . hsc3Is   a  ? hsc3/Get Primitive from Ugen if Ugen is a Primitive. hsc3Is   a  ? hsc3,Multiple channel expansion node constructor. hsc3Type specified . hsc3!Multiple channel expansion node ( ) predicate. Sees into Mrg. hsc3Output channels of Ugen as a list. If required, preserves the RHS of and Mrg node in channel 0. hsc3Number of channels to expand to. This function sees into Mrg, and is defined only for Mce nodes. hsc3Erroring variant. hsc3Extend Ugen to specified degree. Follows "leftmost" rule for Mrg nodes. hsc3.Is Mce required, ie. are any input values Mce? hsc3Apply Mce transform to a list of inputs. The transform extends each input so all are of equal length, and then transposes the matrix. mceInputTransform [mce2 1 2,mce2 3 4] == Just [[1,3],[2,4]] mceInputTransform [mce2 1 2,mce2 3 4,mce3 5 6 7] == Just [[1,3,5],[2,4,6],[1,3,7]] mceInputTransform [mce2 (mce2 1 2) (mce2 3 4),mce2 5 6] == Just [[mce2 1 2,5],[mce2 3 4,6]] hsc30Build a Ugen after Mce transformation of inputs. hsc3True if Mce is an immediate proxy for a multiple-out Primitive. This is useful when disassembling graphs, ie. ugen_graph_forth_pp at hsc3-db. It's also useful when editing a Primitive after it is constructed, as in bracketUgen. hsc3Attach Brackets (initialisation and cleanup message sequences) to Ugen. For simplicity and clarity, brackets can only be attached to Primitive, Constant and Control nodes. This will look into the direct (immediate) proxies of a Primitive. hsc3Retrieve Brackets from Ugen. hsc3 Ensure input   is valid, ie. not a sink. hsc3 Constant value node constructor. hsc3Type specialised  . hsc3Type specialised  . hsc3Type specialised  . hsc3&Unit generator proxy node constructor. hsc3Determine the rate of a Ugen. hsc3'Apply proxy transformation if required. hsc3Filters with DemandRate inputs run at ControlRate. This is a little unfortunate, it'd be nicer if the rate in this circumstance could be given. hsc35Construct proxied and multiple channel expanded Ugen.cf = constant function, rs = rate set, r = rate, nm = name, i = inputs, i_mce = list of Mce inputs, o = outputs. hsc3Operator Ugen constructor. hsc3Unary math constructor. hsc33Binary math constructor with constant optimisation. %constant 2 * constant 3 == constant 6 let o = sinOsc ar 440 0 o * 1 == o && 1 * o == o && o * 2 /= o o + 0 == o && 0 + o == o && o + 1 /= o o - 0 == o && 0 - o /= o o / 1 == o && 1 / o /= o o ** 1 == o && o ** 2 /= o hsc3.Plain (non-optimised) binary math constructor. hsc3Is u" the primitive for the named Ugen. hsc3Is u" the primitive for the named Ugen. hsc3Is u( a binary math operator with SPECIAL of k. hsc3Is u an ADD operator? hsc3Is u an MUL operator? hsc3MulAdd re-writer, applicable only directly at add operator Ugen. The MulAdd Ugen is very sensitive to input rates. Add=AudioRate with In|Mul=InitialisationRate|Const will crash scsynth. This only considers primitives that do not have bracketing messages. hsc35MulAdd optimiser, applicable at any Ugen (ie. checks u is an ADD ugen) import Sound.Sc3 g1 = sinOsc ar 440 0 * 0.1 + control ir "x" 0.05 g2 = sinOsc ar 440 0 * control ir "x" 0.1 + 0.05 g3 = control ir "x" 0.1 * sinOsc ar 440 0 + 0.05 g4 = 0.05 + sinOsc ar 440 0 * 0.1 hsc3Sum3 re-writer, applicable only directly at add operator Ugen. This only considers nodes that have no bracketing messages. hsc3Sum3 optimiser, applicable at any u (ie. checks if u is an ADD operator). hsc3  of  . hsc3Ugens are bit patterns. hsc3Unit generators are stochastic. Only un-bracketed constant values are considered. hsc3Unit generators are enumerable. hsc3$Unit generators are orderable (when  Constants). !(constant 2 > constant 1) == True hsc3Unit generators are integral. hsc3Unit generators are real. hsc3#Unit generators are floating point. hsc3Unit generators are fractional. hsc3Unit generators are numbers.= = ` Safe-InferredyN  1 Safe-Inferred{1 hsc3Print constants and labels directly, primitives as un-adorned names, mce as [p,q], mrg as p&q, contols as nm=def, proxies as u@n. Brackets are not printed.  2 Safe-Inferred} hsc3 Variant of  . hsc3Construct unary operator. uop CI "Neg" ar 1 hsc3Construct binary operator. binop CI "*" ar 1 2 == binop CI "Mul" ar 1 2 binop CS "*" ar (ugen "SinOsc" ar [440,0] 1) 0.1 == sinOsc ar 440 0 * 0.1 hsc3Construct deterministic Ugen. let o = ugen "SinOsc" ar [440,0] 1 o == sinOsc ar 440 0 ugen "Out" ar [0, o] 0 == out 0 (sinOsc ar 440 0) hsc3!Construct non-deterministic Ugen. import Sound.Sc3.Common.Uid binop CI "*" ar (nondet "WhiteNoise" (Uid (fromEnum '')) ar [] 1) 0.05  3 Safe-Inferred hsc39Oscillator constructor with constrained set of operating s. hsc3Oscillator constructor with . hsc30Oscillator constructor, rate restricted variant. hsc3;Rate restricted oscillator constructor, setting identifier. hsc3+Oscillator constructor, setting identifier. hsc3 Provided   variant of  . hsc39Variant oscillator constructor with MCE collapsing input. hsc39Variant oscillator constructor with MCE collapsing input. hsc3Rate constrained filter   constructor. hsc3Filter Ugen constructor. hsc3Filter Ugen constructor. hsc3Filter   constructor. hsc3Filter Ugen constructor. hsc3 Provided   filter with   input. hsc35Variant filter constructor with MCE collapsing input. hsc35Variant filter constructor with MCE collapsing input. hsc35Variant filter constructor with MCE collapsing input. hsc31Information unit generators are very specialized.  4 Safe-Inferredl hsc3 Type specialised envelope curve. hsc3 Lift to Ugen.  5 Safe-Inferred hsc3Parameter (name,value) pairs. hsc3ZitaRev binding.  6 Safe-InferredH hsc3Forward wavelet transform. hsc3 Inverse of  . hsc3%Pass wavelets above a threshold, ie.  pv_MagAbove. hsc3Pass wavelets with scale above threshold. hsc3Pass wavelets with time above threshold. hsc3 Product in W domain, ie. pv_Mul.  7 Safe-Inferred@ hsc3Emulation of the sound generation hardware of the Atari TIA chip. hsc3POKEY Chip Sound Simulator hsc3A phasor that can loop. hsc3A phasor that can loop.  8 Safe-Inferred5 hsc3  of  resolveID. hsc3"Depth first traversal of graph at u, stopping at halt_f, else applying map_f to each node. hsc3Right fold of Ugen graph. map Sound.Sc3.Ugen.PP.ugen_concise_pp $ ugenFoldr (:) [] (sinOsc ar 440 0 * 0.1) map Sound.Sc3.Ugen.PP.ugen_concise_pp $ ugenFoldr (:) [] (pan2 (sinOsc ar 440 0) 0.25 0.1) hsc3Fold over Ugen and collect all bracketing messages from all Primitive nodes. hsc3Are there any brackets at Ugen. hsc3Control input node constructor. hsc3Control input node constructor.=Note that if the name begins with a t_ prefix the control is not0 converted to a triggered control. Please see  . hsc3 Variant of   with meta data. hsc3Generate group of two controls. Names are generated according to  hsc3;Generate range controls. Names are generated according to  hsc3.Triggered (kr) control input node constructor. hsc3.Triggered (kr) control input node constructor. hsc3"Set indices at a list of controls. hsc3*Multiple channel expansion for two inputs. hsc3Extract two channels from possible Mce, if there is only one channel it is duplicated. hsc3 Variant of  * that requires input to have two channels. hsc3*Multiple channel expansion for two inputs. hsc3 Variant of  * that requires input to have two channels. hsc35Apply a function to each channel at a unit generator. hsc3Map with element index. hsc3 Variant of   with element index. hsc3*Apply Ugen list operation on Mce contents. hsc3!Reverse order of channels at Mce. hsc3Obtain indexed channel at Mce. hsc33Obtain indexed channel at Mce, indicex wrap around. 9map (\ix -> mceChannelWrap ix (mce [1,2,3,4,5])) [0 .. 9] hsc3?Transpose rows and columns, ie. {{a,b},{c,d}} to {{a,c},{b,d}}. hsc3 Rotate mce k0 places to the right, ie. {a,b,c,d} to {d,a,b,c} ,mceRotate 1 (mce [1,2,3,4]) == mce [4,1,2,3] hsc3? at mce channels of each input, ie. {{a,b},{c,d}} to {a,b,c,d}. /mceConcat (map mce [[1,2],[3,4]]) == mce [1..4] hsc3Collect subarrays of mce. 8mceClump 2 (mce [1,2,3,4]) == mce2 (mce2 1 2) (mce2 3 4) hsc3Foldl1 at channels of mce. hsc3mceReduce of *. hsc3Given unmce" function make halt mce transform. hsc3The halt Mce transform, ie. lift channels of last input into list. This is not used by hsc3, but it is used by hsc3-forth and stsc3. .halt_mce_transform [1,2,mce2 3 4] == [1,2,3,4] hsc3$If the root node of a Ugen graph is mce, transform to mrg. hsc3;Multiple root graph node constructor (left input is output) hsc3Lift a  to a Ugen label (ie. for poll). hsc3,Unpack a label to a length prefixed list of Constants. There is a special case for mce nodes, but it requires labels to be equal length. Properly, poll would not unpack the label, it would be done by the synthdef builder.  unpackLabel False (label "/tmp") hsc3  of . hsc3  of . hsc3 hsc3 hsc3 hsc3 hsc3 hsc3 hsc3 hsc3  operator. hsc3  operator. hsc3:Traverse graph rewriting audio rate nodes as control rate. hsc3:Traverse graph rewriting audio rate nodes as control rate. hsc32Traverse graph rewriting all nodes as demand rate. hsc3Traverse graph rewriting audio and control nodes as initialisation rate. hsc3 Select rewriting function given .6 6 9 Safe-Inferred  hsc3Select q or r by p, ie. &if p == 1 then q else if p == 0 then r. hsc32Separate input into integral and fractional parts. 4ugen_integral_and_fractional_parts 1.5 == mce2 1 0.5 hsc34Fractional midi into integral midi and cents detune. ,ugen_fmidi_to_midi_detune 60.5 == mce2 60 50  : Safe-Inferred hsc3Zero local buffer.ClearBuf does not copy the buffer number through so this is an Mrg node. hsc3/Demand rate weighted random sequence generator. hsc3 Variant on envGen without enumeration types. hsc3Outputs signal for FFT chains, without performing FFT. hsc33Pack demand-rate FFT bin streams into an FFT chain. hsc3(Poll value of input Ugen when triggered. hsc3FFT onset detector. hsc3)FFT feature detector for onset detection.buffer, propsc=0.25, prophfe=0.25, prophfc=0.25, propsf=0.25, threshold=1.0, waittime=0.04 hsc37Ascii string to length prefixed list of constant Ugens. string_to_ugens "/label" == map fromIntegral [6,47,108,97,98,101,108] hsc3Send a reply message from the server back to all registered clients. hsc3Crosscorrelation search and drum pattern matching beat trackerDrumTrack [ControlRate] in=0 lock=0 dynleak=0 tempowt=0 phasewt=0 basswt=0 patternwt=1 prior=0 kicksensitivity=1 snaresensitivity=1 debugmode=0 hsc3demand rate tag system6Dtag [] bufsize=0 v=0 axiom=0 rules=0 recycle=0 mode=0 hsc3Envelope Follower Filter/EnvDetect [AudioRate] in=0 attack=100 release=0 hsc3Envelope Follower9EnvFollow [ControlRate,AudioRate] input=0 decaycoeff=0.99 hsc3(Undocumented class)OnsetStatistics [ControlRate] input=0 windowsize=1 hopsize=0.1 hsc3&Chemical reaction modelling OscillatorOregonator [AudioRate] reset=0 rate=0.01 epsilon=1 mu=1 q=1 initx=0.5 inity=0.5 initz=0.5 hsc3(Undocumented class)OscBank [ControlRate,AudioRate] freq=100 gain=1 saw8=0.5 square8=0.5 saw4=0.5 square4=0.5 saw2=0.5 square2=0.5 saw1=0.5 hsc3Piano physical model.OteyPiano [AudioRate] freq=440 vel=1 t_gate=0 rmin=0.35 rmax=2 rampl=4 rampr=8 rcore=1 lmin=0.07 lmax=1.4 lampl=-4 lampr=4 rho=1 e=1 zb=1 zh=0 mh=1 k=0.2 alpha=1 p=1 hpos=0.142 loss=1 detune=0.0003 hammer_type=1 hsc3Piano physical model.OteyPianoStrings [AudioRate] freq=440 vel=1 t_gate=0 rmin=0.35 rmax=2 rampl=4 rampr=8 rcore=1 lmin=0.07 lmax=1.4 lampl=-4 lampr=4 rho=1 e=1 zb=1 zh=0 mh=1 k=0.2 alpha=1 p=1 hpos=0.142 loss=1 detune=0.0003 hammer_type=1 hsc3(Undocumented class)OteySoundBoard [AudioRate] inp=0 c1=20 c3=20 mix=0.8; FILTER: TRUE hsc3)Return mag and freq data from a CSound pvPVInfo [ControlRate,AudioRate] pvbuffer=0 binNum=0 filePointer=0 hsc3Resynthesize Csound PV dataPVSynth [AudioRate] pvbuffer=0 numBins=0 binStart=0 binSkip=1 filePointer=0 freqMul=1 freqAdd=0 hsc3!Plays FFT data to a memory bufferPV_BinBufRd [ControlRate] buffer=0 playbuf=0 point=1 binStart=0 binSkip=1 numBins=1 clear=0 hsc3)Delay and Feedback on a bin by bin basis.PV_BinDelay [ControlRate] buffer=0 maxdelay=0 delaybuf=0 fbbuf=0 hop=0.5 hsc3(Undocumented class)1PV_BinFilter [ControlRate] buffer=0 start=0 end=0 hsc3!Plays FFT data to a memory bufferPV_BinPlayBuf [ControlRate] buffer=0 playbuf=0 rate=1 offset=0 binStart=0 binSkip=1 numBins=1 loop=0 clear=0 hsc3#Plays FFT data from a memory buffer1PV_BufRd [ControlRate] buffer=0 playbuf=0 point=1 hsc3returns common magnitudesPV_CommonMag [ControlRate] bufferA=0 bufferB=0 tolerance=0 remove=0 hsc3multiplies common magnitudesPV_CommonMul [ControlRate] bufferA=0 bufferB=0 tolerance=0 remove=0 hsc3%simple spectral compression/expansionPV_Compander [ControlRate] buffer=0 thresh=50 slopeBelow=1 slopeAbove=1 hsc3zero bins with interpolation2PV_Cutoff [ControlRate] bufferA=0 bufferB=0 wipe=0 hsc3.Return the even numbered bins in an FFT buffer!PV_EvenBin [ControlRate] buffer=0 hsc3'extract a repeating loop out from audioPV_ExtractRepeat [ControlRate] buffer=0 loopbuf=0 loopdur=0 memorytime=30 which=0 ffthop=0.5 thresh=1 hsc3Freeze FFT frames)PV_Freeze [ControlRate] buffer=0 freeze=0 hsc3.Store FFT data in another buffer for other use1PV_FreqBuffer [ControlRate] buffer=0 databuffer=0 hsc3Invert FFT frames PV_Invert [ControlRate] buffer=0 hsc3.Store FFT data in another buffer for other use0PV_MagBuffer [ControlRate] buffer=0 databuffer=0 hsc3(Undocumented class) PV_MagExp [ControlRate] buffer=0 hsc3(reduces magnitudes above or below thresh3PV_MagGate [ControlRate] buffer=0 thresh=1 remove=0 hsc3(Undocumented class) PV_MagLog [ControlRate] buffer=0 hsc3#Remap magnitudes to a new mag curve)PV_MagMap [ControlRate] buffer=0 mapbuf=0 hsc3subtract spectral energy6PV_MagMinus [ControlRate] bufferA=0 bufferB=0 remove=1 hsc3(Undocumented class)#PV_MagMulAdd [ControlRate] buffer=0 hsc3(Undocumented class)-PV_MagScale [ControlRate] bufferA=0 bufferB=0 hsc3$Smooth spectral magnitudes over time.PV_MagSmooth [ControlRate] buffer=0 factor=0.1 hsc3(Undocumented class)BHiShelf [AudioRate] in=0 freq=1200 rs=1 db=0; FILTER: TRUEhsc3512db/oct rolloff - 2nd order resonant Low Pass Filter9BLowPass [AudioRate] in=0 freq=1200 rq=1; FILTER: TRUEhsc3 Low Shelf?BLowShelf [AudioRate] in=0 freq=1200 rs=1 db=0; FILTER: TRUEhsc3&2nd order Butterworth bandpass filter.?BPF [ControlRate,AudioRate] in=0 freq=440 rq=1; FILTER: TRUEhsc3Two zero fixed midpass.2BPZ2 [ControlRate,AudioRate] in=0; FILTER: TRUEhsc3Parametric equalizer=BPeakEQ [AudioRate] in=0 freq=1200 rq=1 db=0; FILTER: TRUEhsc3)2nd order Butterworth band reject filter.?BRF [ControlRate,AudioRate] in=0 freq=440 rq=1; FILTER: TRUEhsc3Two zero fixed midcut.2BRZ2 [ControlRate,AudioRate] in=0; FILTER: TRUEhsc3Stereo signal balancerBalance2 [ControlRate,AudioRate] left=0 right=0 pos=0 level=1; FILTER: TRUEhsc3!physical model of bouncing object:Ball [ControlRate,AudioRate] in=0 g=1 damp=0 friction=0.01hsc3Autocorrelation beat tracker&BeatTrack [ControlRate] chain=0 lock=0hsc3Template matching beat trackerBeatTrack2 [ControlRate] busindex=0 numfeatures=0 windowsize=2 phaseaccuracy=0.02 lock=0 weightingscheme=0hsc32D Ambisonic B-format panner.Lag2 [ControlRate,AudioRate] in=0 lagTime=0.1; FILTER: TRUEhsc3Exponential lagLag2UD [ControlRate,AudioRate] in=0 lagTimeU=0.1 lagTimeD=0.1; FILTER: TRUEhsc3Exponential lag>Lag3 [ControlRate,AudioRate] in=0 lagTime=0.1; FILTER: TRUEhsc3Exponential lagLag3UD [ControlRate,AudioRate] in=0 lagTimeU=0.1 lagTimeD=0.1; FILTER: TRUEhsc3+Read a control signal from a bus with a lag4LagIn [ControlRate] bus=0 lag=0.1; NC INPUT: Truehsc3Exponential lagLagUD [ControlRate,AudioRate] in=0 lagTimeU=0.1 lagTimeD=0.1; FILTER: TRUEhsc3.Output the last value before the input changedLastValue [ControlRate,AudioRate] in=0 diff=0.01; FILTER: TRUEhsc3Sample and hold:Latch [ControlRate,AudioRate] in=0 trig=0; FILTER: TRUEhsc3Latoocarfian chaotic generatorLatoocarfianC [AudioRate] freq=22050 a=1 b=3 c=0.5 d=0.5 xi=0.5 yi=0.5hsc3Latoocarfian chaotic generatorLatoocarfianL [AudioRate] freq=22050 a=1 b=3 c=0.5 d=0.5 xi=0.5 yi=0.5hsc3Latoocarfian chaotic generatorLatoocarfianN [AudioRate] freq=22050 a=1 b=3 c=0.5 d=0.5 xi=0.5 yi=0.5hsc3 Remove DC?LeakDC [ControlRate,AudioRate] in=0 coef=0.995; FILTER: TRUEhsc3Output least changed+LeastChange [ControlRate,AudioRate] a=0 b=0hsc3 Peak limiter:Limiter [AudioRate] in=0 level=1 dur=0.01; FILTER: TRUEhsc3%Linear congruential chaotic generator5LinCongC [AudioRate] freq=22050 a=1.1 c=0.13 m=1 xi=0hsc3%Linear congruential chaotic generator5LinCongL [AudioRate] freq=22050 a=1.1 c=0.13 m=1 xi=0hsc3%Linear congruential chaotic generator5LinCongN [AudioRate] freq=22050 a=1.1 c=0.13 m=1 xi=0hsc3*Map a linear range to an exponential rangeLinExp [InitialisationRate,ControlRate,AudioRate] in=0 srclo=0 srchi=1 dstlo=1 dsthi=2; FILTER: TRUEhsc3Two channel linear pan.LinPan2 [ControlRate,AudioRate] in=0 pos=0 level=1; FILTER: TRUEhsc3Skewed random number generator.:LinRand [InitialisationRate] lo=0 hi=1 minmax=0; NONDEThsc3Monad variant of LinRand.hsc3Unsafe variant of LinRand.hsc3Two channel linear crossfade.LinXFade2 [ControlRate,AudioRate] inA=0 inB=0 pan=0 level=1; FILTER: TRUE, PSUEDO INPUTS: [3]hsc3Line generator.Line [ControlRate,AudioRate] start=0 end=1 dur=1 doneAction=0; ENUMERATION INPUTS: 3=DoneActionhsc3!Simple linear envelope generator.Linen [ControlRate] gate=1 attackTime=0.01 susLevel=1 releaseTime=1 doneAction=0; ENUMERATION INPUTS: 4=DoneActionhsc3$Allocate a buffer local to the synthLocalBuf [InitialisationRate] numChannels=1 numFrames=1; REORDERS INPUTS: [1,0], NONDEThsc3Monad variant of LocalBuf.hsc3Unsafe variant of LocalBuf.hsc3,Define and read from buses local to a synth.LocalIn [ControlRate,AudioRate] *default=0; MCE=1, NC INPUT: Truehsc3 Write to buses local to a synth.LocalOut [ControlRate,AudioRate] *channelsArray=0; MCE=1, FILTER: TRUEhsc3Chaotic noise functionLogistic [ControlRate,AudioRate] chaosParam=3 freq=1000 init=0.5hsc3Lorenz chaotic generatorLorenzL [AudioRate] freq=22050 s=10 r=28 b=2.667 h=0.05 xi=0.1 yi=0 zi=0hsc3-Extraction of instantaneous loudness in sones1Loudness [ControlRate] chain=0 smask=0.25 tmask=1hsc3#Mel frequency cepstral coefficients&MFCC [ControlRate] chain=0 numcoeff=13hsc3Reduce precision.MantissaMask [ControlRate,AudioRate] in=0 bits=3; FILTER: TRUEhsc3Median filter.=Median [ControlRate,AudioRate] length=3 in=0; FILTER: TRUEhsc3Parametric filter.MidEQ [ControlRate,AudioRate] in=0 freq=440 rq=1 db=0; FILTER: TRUEhsc36Minimum difference of two values in modulo arithmeticsModDif [InitialisationRate,ControlRate,AudioRate] x=0 y=0 mod=1; FILTER: TRUEhsc35Moog VCF implementation, designed by Federico FontanaMoogFF [ControlRate,AudioRate] in=0 freq=100 gain=2 reset=0; FILTER: TRUEhsc3Output most changed.;MostChange [ControlRate,AudioRate] a=0 b=0; FILTER: TRUEhsc3Mouse button Ugen.3MouseButton [ControlRate] minval=0 maxval=1 lag=0.2hsc3Cursor tracking Ugen.MouseX [ControlRate] minval=0 maxval=1 warp=0 lag=0.2; ENUMERATION INPUTS: 2=Warphsc3Cursor tracking Ugen.MouseY [ControlRate] minval=0 maxval=1 warp=0 lag=0.2; ENUMERATION INPUTS: 2=Warphsc3Sum of uniform distributions.3NRand [InitialisationRate] lo=0 hi=1 n=0; NONDEThsc3Monad variant of NRand.hsc3Unsafe variant of NRand.hsc3(Undocumented class)NodeID [InitialisationRate]hsc3Flattens dynamics.=Normalizer [AudioRate] in=0 level=1 dur=0.01; FILTER: TRUEhsc3Number of audio busses."NumAudioBuses [InitialisationRate]hsc3Number of open buffers.NumBuffers [InitialisationRate]hsc3Number of control busses.$NumControlBuses [InitialisationRate]hsc3Number of input busses."NumInputBuses [InitialisationRate]hsc3Number of output busses.#NumOutputBuses [InitialisationRate]hsc3#Number of currently running synths.1NumRunningSynths [InitialisationRate,ControlRate]hsc34Write a signal to a bus with sample accurate timing.OffsetOut [ControlRate,AudioRate] bus=0 *channelsArray=0; MCE=1, FILTER: TRUEhsc3One pole filter.>OnePole [ControlRate,AudioRate] in=0 coef=0.5; FILTER: TRUEhsc3One zero filter.>OneZero [ControlRate,AudioRate] in=0 coef=0.5; FILTER: TRUEhsc3Onset detectorOnsets [ControlRate] chain=0 threshold=0.5 odftype=3 relaxtime=1 floor=0.1 mingap=10 medianspan=11 whtype=1 rawodf=0hsc3#Interpolating wavetable oscillator.5Osc [ControlRate,AudioRate] bufnum=0 freq=440 phase=0hsc3&Noninterpolating wavetable oscillator.6OscN [ControlRate,AudioRate] bufnum=0 freq=440 phase=0hsc3Write a signal to a bus.Out [ControlRate,AudioRate] bus=0 *channelsArray=0; MCE=1, FILTER: TRUEhsc3.Very fast sine grain with a parabolic envelope.PSinGrain [AudioRate] freq=440 dur=0.2 amp=0.1hsc3Complex addition.(PV_Add [ControlRate] bufferA=0 bufferB=0hsc3Scramble bins.PV_BinScramble [ControlRate] buffer=0 wipe=0 width=0.2 trig=0; NONDEThsc3 Monad variant of PV_BinScramble.hsc3!Unsafe variant of PV_BinScramble.hsc3Shift and stretch bin position.=PV_BinShift [ControlRate] buffer=0 stretch=1 shift=0 interp=0hsc3*Combine low and high bins from two inputs.3PV_BinWipe [ControlRate] bufferA=0 bufferB=0 wipe=0hsc3 Zero bins.*PV_BrickWall [ControlRate] buffer=0 wipe=0hsc3Complex plane attack.6PV_ConformalMap [ControlRate] buffer=0 areal=0 aimag=0hsc3Complex conjugatePV_Conj [ControlRate] buffer=0hsc3Copy an FFT buffer)PV_Copy [ControlRate] bufferA=0 bufferB=0hsc3Copy magnitudes and phases..PV_CopyPhase [ControlRate] bufferA=0 bufferB=0hsc3Random phase shifting.)PV_Diffuser [ControlRate] buffer=0 trig=0hsc3Complex division(PV_Div [ControlRate] bufferA=0 bufferB=0hsc3$Pass bins which are a local maximum..PV_LocalMax [ControlRate] buffer=0 threshold=0hsc3Pass bins above a threshold..PV_MagAbove [ControlRate] buffer=0 threshold=0hsc3Pass bins below a threshold..PV_MagBelow [ControlRate] buffer=0 threshold=0hsc3Clip bins to a threshold.-PV_MagClip [ControlRate] buffer=0 threshold=0hsc3Division of magnitudes9PV_MagDiv [ControlRate] bufferA=0 bufferB=0 zeroed=0.0001hsc3Freeze magnitudes.,PV_MagFreeze [ControlRate] buffer=0 freeze=0hsc3Multiply magnitudes.+PV_MagMul [ControlRate] bufferA=0 bufferB=0hsc3Multiply magnitudes by noise."PV_MagNoise [ControlRate] buffer=0hsc3)shift and stretch magnitude bin position.4PV_MagShift [ControlRate] buffer=0 stretch=1 shift=0hsc3Average magnitudes across bins.)PV_MagSmear [ControlRate] buffer=0 bins=0hsc3Square magnitudes.$PV_MagSquared [ControlRate] buffer=0hsc3Maximum magnitude.(PV_Max [ControlRate] bufferA=0 bufferB=0hsc3Minimum magnitude.(PV_Min [ControlRate] bufferA=0 bufferB=0hsc3Complex multiply.(PV_Mul [ControlRate] bufferA=0 bufferB=0hsc3 Shift phase.8PV_PhaseShift [ControlRate] buffer=0 shift=0 integrate=0hsc3Shift phase by 270 degrees.'PV_PhaseShift270 [ControlRate] buffer=0hsc3Shift phase by 90 degrees.&PV_PhaseShift90 [ControlRate] buffer=0hsc3Pass random bins.;PV_RandComb [ControlRate] buffer=0 wipe=0 trig=0; NONDEThsc3Monad variant of PV_RandComb.hsc3Unsafe variant of PV_RandComb.hsc3Crossfade in random bin order.PV_RandWipe [ControlRate] bufferA=0 bufferB=0 wipe=0 trig=0; NONDEThsc3Monad variant of PV_RandWipe.hsc3Unsafe variant of PV_RandWipe.hsc3Make gaps in spectrum.?PV_RectComb [ControlRate] buffer=0 numTeeth=0 phase=0 width=0.5hsc3Make gaps in spectrum.PV_RectComb2 [ControlRate] bufferA=0 bufferB=0 numTeeth=0 phase=0 width=0.5hsc3Two channel equal power pan.Pan2 [ControlRate,AudioRate] in=0 pos=0 level=1; FILTER: TRUEhsc3Four channel equal power pan.7Pan4 [ControlRate,AudioRate] in=0 xpos=0 ypos=0 level=1hsc3Azimuth pannerPanAz [ControlRate,AudioRate] in=0 pos=0 level=1 width=2 orientation=0.5; NC INPUT: True, FILTER: TRUEhsc3Ambisonic B-format panner.>PanB [ControlRate,AudioRate] in=0 azimuth=0 elevation=0 gain=1hsc32D Ambisonic B-format panner.PanB2 [ControlRate,AudioRate] in=0 azimuth=0 gain=1; FILTER: TRUEhsc3!Real-time partitioned convolution.PartConv [AudioRate] in=0 fftsize=0 irbufnum=0hsc3When triggered, pauses a node.Pause [ControlRate] gate=0 id=0hsc3&When triggered, pause enclosing synth.PauseSelf [ControlRate] in=0hsc3!FIXME: PauseSelfWhenDone purpose.%PauseSelfWhenDone [ControlRate] src=0hsc3Track peak signal amplitude.9Peak [ControlRate,AudioRate] in=0 trig=0; FILTER: TRUEhsc3Track peak signal amplitude.PeakFollower [ControlRate,AudioRate] in=0 decay=0.999; FILTER: TRUEhsc3,A resettable linear ramp between two levels.Phasor [ControlRate,AudioRate] trig=0 rate=1 start=0 end=1 resetPos=0hsc3 Pink Noise.-PinkNoise [ControlRate,AudioRate] ; NONDEThsc3Monad variant of PinkNoise.hsc3Unsafe variant of PinkNoise.hsc3Autocorrelation pitch followerPitch [ControlRate] in=0 initFreq=440 minFreq=60 maxFreq=4000 execFreq=100 maxBinsPerOctave=16 median=1 ampThreshold=0.01 peakThreshold=0.5 downSample=1 clar=0hsc3Time domain pitch shifter.PitchShift [AudioRate] in=0 windowSize=0.2 pitchRatio=1 pitchDispersion=0 timeDispersion=0; FILTER: TRUEhsc3Sample playback oscillator.PlayBuf [ControlRate,AudioRate] bufnum=0 rate=1 trigger=1 startPos=0 loop=0 doneAction=0; NC INPUT: True, ENUMERATION INPUTS: 4=Loop, 5=DoneActionhsc3A Karplus-Strong UgenPluck [AudioRate] in=0 trig=1 maxdelaytime=0.2 delaytime=0.2 decaytime=1 coef=0.5; FILTER: TRUEhsc3Band limited pulse wave.0Pulse [ControlRate,AudioRate] freq=440 width=0.5hsc3Pulse counter.PulseCount [ControlRate,AudioRate] trig=0 reset=0; FILTER: TRUEhsc3Pulse divider.PulseDivider [ControlRate,AudioRate] trig=0 div=2 start=0; FILTER: TRUEhsc3'General quadratic map chaotic generator2QuadC [AudioRate] freq=22050 a=1 b=-1 c=-0.75 xi=0hsc3'General quadratic map chaotic generator2QuadL [AudioRate] freq=22050 a=1 b=-1 c=-0.75 xi=0hsc3'General quadratic map chaotic generator2QuadN [AudioRate] freq=22050 a=1 b=-1 c=-0.75 xi=0hsc3A resonant high pass filter.RHPF [ControlRate,AudioRate] in=0 freq=440 rq=1; FILTER: TRUEhsc3A resonant low pass filter.RLPF [ControlRate,AudioRate] in=0 freq=440 rq=1; FILTER: TRUEhsc3Number of radians per sample.%RadiansPerSample [InitialisationRate]hsc3,Break a continuous signal into line segments>Ramp [ControlRate,AudioRate] in=0 lagTime=0.1; FILTER: TRUEhsc3Single random number generator..Rand [InitialisationRate] lo=0 hi=1; NONDEThsc3Monad variant of Rand.hsc3Unsafe variant of Rand.hsc3$Set the synth's random generator ID.,RandID [InitialisationRate,ControlRate] id=0hsc3'Sets the synth's random generator seed.RandSeed [InitialisationRate,ControlRate,AudioRate] trig=0 seed=56789hsc3 Record or overdub into a Buffer.RecordBuf [ControlRate,AudioRate] bufnum=0 offset=0 recLevel=1 preLevel=0 run=1 loop=1 trigger=1 doneAction=0 *inputArray=0; MCE=1, REORDERS INPUTS: [8,0,1,2,3,4,5,6,7], ENUMERATION INPUTS: 5=Loop, 7=DoneActionhsc34Send signal to a bus, overwriting previous contents.ReplaceOut [ControlRate,AudioRate] bus=0 *channelsArray=0; MCE=1, FILTER: TRUEhsc3Resonant filter.Resonz [ControlRate,AudioRate] in=0 freq=440 bwr=1; FILTER: TRUEhsc3Ringing filter.Ringz [ControlRate,AudioRate] in=0 freq=440 decaytime=1; FILTER: TRUEhsc3Rotate a sound field.>Rotate2 [ControlRate,AudioRate] x=0 y=0 pos=0; FILTER: TRUEhsc3Track maximum level.?RunningMax [ControlRate,AudioRate] in=0 trig=0; FILTER: TRUEhsc3Track minimum level.?RunningMin [ControlRate,AudioRate] in=0 trig=0; FILTER: TRUEhsc3Running sum over n framesRunningSum [ControlRate,AudioRate] in=0 numsamp=40; FILTER: TRUEhsc3%Second order filter section (biquad).SOS [ControlRate,AudioRate] in=0 a0=0 a1=0 a2=0 b1=0 b2=0; FILTER: TRUEhsc3Duration of one sample.SampleDur [InitialisationRate]hsc3Server sample rate.SampleRate [InitialisationRate]hsc3#Remove infinity, NaN, and denormalsSanitize [ControlRate,AudioRate] in=0 replace=0; FILTER: TRUEhsc3Band limited sawtooth.$Saw [ControlRate,AudioRate] freq=440hsc3Schmidt trigger.Schmidt [InitialisationRate,ControlRate,AudioRate] in=0 lo=0 hi=1; FILTER: TRUEhsc3&Select output from an array of inputs.Select [InitialisationRate,ControlRate,AudioRate] which=0 *array=0; MCE=1, FILTER: TRUEhsc3:Send a trigger message from the server back to the client.SendTrig [ControlRate,AudioRate] in=0 id=0 value=0; FILTER: TRUEhsc3Set-reset flip flop.SetResetFF [ControlRate,AudioRate] trig=0 reset=0; FILTER: TRUEhsc3 Wave shaper.=Shaper [ControlRate,AudioRate] bufnum=0 in=0; FILTER: TRUEhsc3(Interpolating sine wavetable oscillator./SinOsc [ControlRate,AudioRate] freq=440 phase=0hsc3Feedback FM oscillator4SinOscFB [ControlRate,AudioRate] freq=440 feedback=0hsc3Slew rate limiter. Safe-InferredS~hsc3Constant form of rand Ugen.hsc3Constant form of iRand Ugen.hsc3 Optimise   graph by re-writing rand and iRand Ugens that have  inputs. This, of course, changes the nature of the graph, it is no longer randomised at the server. It's a useful transformation for very large graphs which are being constructed and sent each time the graph is played. import Sound.Sc3.Ugen.Dot let u = sinOsc ar (randId 'a' 220 440) 0 * 0.1 draw (u + ugen_optimise_ir_rand u)hsc3 Optimise  + graph by re-writing binary operators with  inputs. The standard graph constructors already do this, however subsequent optimisations, ie. , can re-introduce these sub-graphs, and the Plain% graph constructors are un-optimised. let u = constant u 5 * u 10 == u 50 u 5 ==** u 5 == u 1 u 5 >** u 4 == u 1 u 5 <=** u 5 == u 1 abs (u (-1)) == u 1 u 5 / u 2 == u 2.5 min (u 2) (u 3) == u 2 max (u 1) (u 3) == u 3 let u = lfPulse ar (2 ** randId '' (-9) 1) 0 0.5 let u' = ugen_optimise_ir_rand u draw (mix (mce [u,u',ugen_optimise_const_operator u'])) 9ugen_optimise_const_operator (Bindings.mulAdd 3 1 0) == 3hsc3  of .hsc3Constant optimising MulAdd. mulAddOptimised (sinOsc ar 440 0) 1 0 == sinOsc ar 440 0 mulAddOptimised (sinOsc ar 440 0) 0.1 0 == sinOsc ar 440 0 * 0.1 mulAddOptimised (sinOsc ar 440 0) 1 1 == sinOsc ar 440 0 + 1 mulAddOptimised (sinOsc ar 440 0) 0.1 1 == mulAdd (sinOsc ar 440 0) 0.1 1? Safe-InferredUhsc3Pseudo-infinite constant Ugen.hsc3Ugen form of ceilingE.hsc3Midi note number and velocity data is in (0, 127). This maps (0,1) to (0,127), i.e. is it (* 127).hsc3midiCps of (0,1) scaled to (0,127). To make control signal data uniform, all control signals are in (0, 1).hsc3Optimised Ugen sum function.hsc3Apply the Ugen processor f k times in sequence to i, ie. for k=4 f (f (f (f i))).@ Safe-InferredY,hsc3Construct a list of Ugens by applying f to consecutive identifiers (from z) and indices (from 0).hsc3Construct a list of Ugens by applying f at consecutive indices (from 0).hsc3Construct a list of Ugens by applying f at consecutive indices (from 0).hsc3  of hsc3  of  f of  n.hsc3 Applicative variant of mceGenId.hsc3Count   channels.hsc3 Mix divided by number of inputs.hsc3 Construct an Mce array of Ugens.hsc3  of hsc3Type specialised mceFillhsc3!Collapse possible mce by summing.hsc3Mix variant, sum to n channels.hsc3 of hsc3Type specialised mixFillhsc3Type specialised mixFillhsc3 of hsc3Monad variant on mixFill.A Safe-Inferred^Mhsc3Ugen primitive set. Sees through Proxy and Mrg, possible multiple primitives for Mce.hsc3Heuristic based on primitive name (FFT, PV_...). Note that IFFT is at control rate, not PV_... rate.hsc3 Variant on primitive_is_pv_rate.hsc3Traverse input graph until an FFT or PV_Split node is encountered, and then locate the buffer input. Biases left at Mce nodes. import Sound.Sc3 let z = soundIn 4 let f1 = fft 10 z 0.5 0 1 0 let f2 = ffta 'a' 1024 z 0.5 0 1 0 pv_track_buffer (pv_BrickWall f1 0.5) == Right 10 pv_track_buffer (pv_BrickWall f2 0.5) == Right (localBuf 'a' 1024 1)hsc3Buffer node number of frames. Biases left at Mce nodes. Sees through LocalBuf, otherwise uses  bufFrames. buffer_nframes 10 == bufFrames IR 10 buffer_nframes (control KR "b" 0) == bufFrames KR (control KR "b" 0) buffer_nframes (localBuf '' 2048 1) == 2048hsc3 then .hsc3Ugen is required to be the root node of complete graph. This function returns the name of the output Ugen (ie. Out or an allowed variant) and the input to that Ugen. It allows multiple-root graphs. It is in some sense the inverse of wrapOut.B Safe-Inferredp?hsc34-tuple to count K_Type>s, ie. (InitialisationRate,ControlRate,TriggerRate,AudioRate).hsc35All the elements of a U_Node_U, except the u_node_id.hsc3)Type to represent a unit generator graph.hsc3Sum-type to represent nodes in unit generator graph. _C = constant, _K = control, _U = ugen, _P = proxy.hsc3A connection from  to .hsc3A destination port.hsc3Type to represent the left hand side of an edge in a unit generator graph. C = constant, K = control, U = ugen.hsc3 Port index.hsc35Convert from U_Node_K to Control (ie. discard index).hsc3Derive "user" name for U_Nodehsc3Get port_idx for , else 0.hsc3Is  .hsc3Is  a constant.hsc3Predicate to determine if  is a constant with indicated value.hsc3Is  a control.hsc3Predicate to determine if  is a control with indicated name. Names must be unique.hsc3Is  a Ugen.hsc3Compare  values  .hsc3Sort by .hsc3%Equality test, error if not U_Node_K.hsc3Rate of , ie. InitialisationRate for constants. See through 3. Not used at hsc3 but used by hsc3-dot &etc.hsc3Generate a label for  using the type and the .hsc3Calculate all in edges for a .hsc3 Transform  to .hsc3:If controls have been given indices they must be coherent.hsc3 Determine K_Type of a control Ugen at  , or not.hsc3Is  a control Ugen?hsc3Is  an implicit control Ugen?hsc3Is U_Node implicit?hsc36Zero if no local buffers, or if maxLocalBufs is given.hsc3Controls are a special case. We need to know not the overall index but the index in relation to controls of the same type.hsc34Predicate to locate primitive, names must be unique.hsc3Make map associating K_Type with Ugen index.hsc3Count the number of controls of each K_Type.hsc3Construct implicit control unit generator U_Nodes. Unit generators are only constructed for instances of control types that are present.hsc3List of  at e with multiple out edges.hsc3Calculate all edges of a .hsc3 The empty .hsc3Find the maximum  used at !. It is an error if this is not .hsc3Find  with indicated .hsc3Locate  of  in .hsc3Erroring variant.hsc3Insert a constant  into the .hsc3Either find existing  , or insert a new . Brackets are discarded.hsc3Insert a control node into the .hsc3Either find existing  , or insert a new .hsc3 Insert a  primitive  into the .hsc3)Recursively traverse set of Ugen calling .hsc3Run  at inputs and either find existing primitive node or insert a new one. Brackets are discarded.hsc3Proxies do not get stored in the graph. Proxies are always of U nodes.hsc3 Transform   into , appending to existing . Allow rhs of Mrg node to be Mce (splice all nodes into graph).hsc3 Add implicit control Ugens to .hsc3 Add implicit  maxLocalBufs if not present.hsc3 and .hsc3Remove implicit Ugens from hsc3Descendents at  of .hsc3List PV s at  with multiple out edges.hsc3%Error string if graph has an invalid PV& subgraph, ie. multiple out edges at PV node not connecting to  Unpack1FFT & PackFFT, else Nothing.hsc3Variant that runs  as required.hsc3.Transform a unit generator into a graph. > begins with an empty graph, then reverses the resulting   list and sorts the  list, and finally adds implicit nodes and validates PV sub-graphs. import Sound.Sc3 ugen_to_graph (out 0 (pan2 (sinOsc ar 440 0) 0.5 0.1))hsc36Simple statistical analysis of a unit generator graph.hsc3 of .hsc33Find indices of all instances of the named Ugen at Graph$. The index is required when using bc.C Safe-Inferreduohsc3 Transform  to ,  for other  types. let k = U_Node_K 8 ControlRate Nothing "k_8" 0.1 K_ControlRate Nothing node_k_eq k (snd (constant_to_control 8 (U_Node_C 0 0.1)))hsc3If the  is a constant generate a control , else retain .hsc3Lift a set of U_NodeU inputs from constants to controls. The result triple gives the incremented , the transformed , list, and the list of newly minted control s.hsc3Lift inputs at  as required.hsc3 at list of .hsc3Lift constants to controls. ,import Sound.Sc3 import Sound.Sc3.Ugen.Dot let u = out 0 (sinOsc AR 440 0 * 0.1) let g = ugen_to_graph u draw g draw (lift_constants g)D Safe-Inferredwhsc3Generate label for hsc3Any name that does not begin with a letter is considered an operator.hsc3Generate a reconstruction of a Graph. import Sound.Sc3 import Sound.Sc3.Util.Graph import Sound.Sc3.Util.Graph.Reconstruct let k = control KR "bus" 0 let o = sinOsc AR 440 0 + whiteNoise '' AR let u = out k (pan2 (o * 0.1) 0 1) let m = mrg [u,out 1 (impulse AR 1 0 * 0.1)] putStrLn (reconstruct_graph_str "anon" (ugen_to_graph m))hsc3Discards index.E Safe-Inferredxhsc3?Note: Graphs with multiple Control Ugens are not accounted for.hsc3*Read graphdef file and translate to graph.hsc30Read graphdef file, translate to graph, and run  ug_stat_ln.F Safe-Inferred{ hsc38(constants-map,controls,controls-map,ugen-map,ktype-map)hsc3(Int,Int) map.hsc3 Generate 2 translating node identifiers to synthdef indexes.hsc3)Locate index in map given node identifer UID_t.hsc3Lookup K_Type% index from map (erroring variant of ).hsc3 Byte-encode  primitive node.hsc3 Byte-encode  primitive node.hsc3 Byte-encode  primitive node.hsc3)Construct instrument definition bytecode.  G Safe-Inferred+hsc35FM7 variant where input matrices are not in MCE form.hsc3greyhole re-orders parameters as well as unpacking the input signal.in1=0.0 in2=0.0 damping=0.0 delayTime=2.0 diffusion=0.5 feedback=0.9 moddepth=0.1 modfreq=2.0 size=1.0 in delayTime=2.0 damping=0.0 size=1.0 diffusion=0.7 feedback=0.9 modDepth=0.1 modFreq=2.0hsc31Association list giving names for MiBraids modes.hsc3Reverse lookup of .hsc3 of hsc31Association list giving names for MiClouds modes.hsc3Reverse lookup of .hsc3 of hsc31Association list giving names for MiPlaits modes.hsc3Reverse lookup of .hsc3 of hsc31Association list giving names for MiPlaits modes.hsc3Reverse lookup of .hsc3 of hsc3"pulse signal as difference of two sawDPW signals.hsc3 Variant that unpacks the output mce node.hsc3A pv_Split variant, like ffta, that allocates a localBuf2 by tracing the input graph to locate the parent FFT or PV_Split node.hsc3 Variant that unpacks the output mce node.H Safe-Inferredhsc34Generate a localBuf and use setBuf to initialise it.hsc3balance2 with Mce input.hsc3524db/oct rolloff - 4th order resonant Low Pass Filterhsc3424db/oct rolloff - 4th order resonant Hi Pass Filterhsc3!Buffer reader (no interpolation).hsc3%Buffer reader (linear interpolation).hsc3$Buffer reader (cubic interpolation).hsc3Triggers when a value changeshsc3  variant of .hsc3liftUid of .hsc3  of .hsc3Demand rate (:) function.hsc3Demand rate (:) function.hsc3+Dynamic klang, dynamic sine oscillator bankhsc33Dynamic klank, set of non-fixed resonating filters.hsc3 with input range of (-1,1).hsc3 Variant of / with arguments to make writing post-fix nicer.hsc3Variant FFT constructor with default values for hop size (0.5), window type (0), active status (1) and window size (0).hsc3 variant that allocates . let c = ffta '' 2048 (soundIn 0) 0.5 0 1 0 in audition (out 0 (ifft c 0 0))hsc3Sum of  and .hsc3Frequency shifter, in terms of  (see also ).hsc3Ugen function to re-trigger an EnvGen envelope. Inputs are gate (as set at EnvGen) and reset. The four state logic is: (1,0)->1 (1,1)->-1 (0,1)->0 (0,0)->0. If the gate input to EnvGen.kr is -1 the envelope ramps to zero in one control period. The reset input sequence 0,1,0 when the gate is open produces (1,-1,1), which resets the envelope. ?map (uncurry gateReset) [(1,0),(1,1),(0,1),(0,0)] == [1,-1,0,0]hsc3 Variant of  using FFT (with a delay) for better results. Buffer should be 2048 or 1024. 2048 = better results, more delay. 1024 = less delay, little choppier results.hsc30Variant ifft with default value for window type.hsc3Generalised Klan(kg) specification rule. f unwraps inputs, g/ wraps output. let r = [220,0.2,0,219,0.1,1,221,0.1,2] in klanx_spec_f id id [220,219,221] [0.2,0.1,0.1] [0,1,2] == rhsc3Format frequency, amplitude and decay time data as required for klank.hsc3 Variant of  for non-Ugen inputs.hsc3 Variant of  for Mce inputs.hsc3Format frequency, amplitude and decay time data as required for klank.hsc3Variant for non-Ugen inputs.hsc3 Variant of  for Mce inputs.hsc3=Randomly select one of a list of Ugens (initialisation rate).hsc3liftUid of .hsc3 of (-1,1).hsc3 of (0,1).hsc32Map from one linear range to another linear range.hsc3 where source is (0,1).hsc3 where source is (-1,1).hsc3Variant with defaults of zero.hsc3 Generate an  Ugen with fadeTime and gate controls. import Sound.Sc3 audition (out 0 (makeFadeEnv 1 * sinOsc ar 440 0 * 0.1)) withSc3 (send (n_set1 (-1) "gate" 0))hsc3!Variant that is randomly pressed.hsc3 Randomised mouse Ugen (see also mouseX' and mouseY').hsc31Variant that randomly traverses the mouseX space.hsc31Variant that randomly traverses the mouseY space.hsc33Translate onset type string to constant Ugen value.hsc38Onset detector with default values for minor parameters.hsc3=Format magnitude and phase data data as required for packFFT.hsc3=Calculate size of accumulation buffer given FFT and IR sizes.hsc3PM oscillator. cf = carrier frequency, mf = modulation frequency, pm = pm-index = 0.0, mp = mod-phase = 0.0hsc3 Variant of   that generates an   value with the input signal at left, and that allows a constant  frequency input in place of a trigger.hsc3 Variant of ) offset so zero if the first private bus.hsc3 Variant of ) offset so zero if the first private bus.hsc3Apply function f to each bin of an FFT chain, f receives magnitude, phase and index and returns a (magnitude,phase).hsc3dur and hop are in seconds,  frameSize and  sampleRate0 in frames, though the latter maybe fractional. Unpack an FFT chain into separate demand-rate FFT bin streams.hsc3VarLag in terms of envGen. Note: in SC3 curvature and warp are separate arguments.hsc3k channel white noise. whiteNoiseN 2 ar * 0.1hsc3If z isn't a sink node route to an out node writing to bus . If fadeTime is given multiply by . import Sound.Sc3 audition (wrapOut (Just 1) (sinOsc ar 440 0 * 0.1)) import Sound.Osc withSc3 (sendMessage (n_set1 (-1) "gate" 0))hsc3Cross-fading version of .hsc3.An oscillator that reads through a table once.I Safe-Inferredhsc3Control Specificier. (name,default,(minValue,maxValue,warpName))hsc3Sequence of 16 continous controller inputs arranged as two Ctl8 sequences.hsc39Sequence of 8 continous controller inputs in range (0-1).hsc3'(ccEventAddr, ccEventIncr, ccEventZero)ccEventAddr = k0 = index of control bus zero for event system, ccEventIncr = stp = voice index increment, ccEventZero = c0 = offset for event voices at current serverhsc3$(v, w, x, y, z, o, rx, ry, p, px, _)v = voice, w = gate, z = force/pressure, o = orientation/angle, r = radius, p = pitchhsc3Translate list to Event.hsc3c = event number (zero indexed)hsc3c0 = index of voice (channel) zero for event set, n = number of voices (channels)hsc3eventVoicerAddr! with default (addr, inct, zero).hsc3Synonym for ccEventVoicer.hsc3eventVoicerAddr with   inputs for  eventAddr,  eventIncr and  eventZero.hsc3Given g and p fields of an  derive a . from g and a trigger derived from monitoring g and p for changed values.hsc3k0 = index of control bus zerohsc3 ctlVoicerAddr with   inputs for CtlAddr and CtlZero.hsc3ctl16VoicerAddr with   inputs for CtlAddr and CtlZero.hsc3Comma separated, no spaces.hsc3Semicolon separated, no spaces. control_spec_seq_parse "freq:220,110,440,exp;amp:0.1,0,1,amp;pan:0,-1,1,lin"hsc3-Comma separated, 6 decimal places, no spaces.hsc3Semicolon separated, no spaces. control_spec_seq_print (control_spec_seq_parse "freq:220,220,440,exp;amp:0.1,0,1,amp;pan:0,-1,1,lin")hsc3See SCClassLibraryCommon"Control/Spec:ControlSpec.initClass6"ControlSpec defines the range and curve of a control"This list adds default values.hsc3See Kyma X Revealed, p.403"The following EventValue names are associated with initial ranges other than (0,1). EventValue names are not case-sensitive.">This list adds curve specifiers as strings and default values. let x = Data.List.intersect (map fst sc3_control_spec) (map fst kyma_event_value_ranges) x == ["beats","boostcut","freq","rate"] let c z = let (p,q) = unzip z in let f i = filter (flip elem i . fst) in zip (f p sc3_control_spec) (f q kyma_event_value_ranges) c (zip x x) c [("lofreq","freqlow"),("midfreq","freqmid")] lookup "freqhigh" kyma_event_value_rangesd Safe-Inferred J Safe-Inferredhsc3The SC3 default instrument   graph.hsc3A Gabor grain, envelope is by .hsc3A sine grain, envelope is by  of .hsc3!Trivial file playback instrument.If use_gate is  there is a gate parameter and the synth ends either when the sound file ends or the gate closes, else there is a sustain parameter to indicate the duration. In both cases a linear envelope with a decay time of decay is applied.The rdelay parameter sets the maximum pre-delay time (in seconds), each instance is randomly pre-delayed between zero and the indicated time. The  ramplitude5 parameter sets the maximum amplitude offset of the amp parameter, each instance is randomly amplified between zero and the indicated value.K Safe-InferredZhsc3A named unit generator graph.hsc3 Alias for .hsc3The SC3 default instrument , see default_ugen_graph. import Sound.Osc import Sound.Sc3 withSc3 (sendMessage (d_recv defaultSynthdef)) audition defaultSynthdefhsc3The SC3 default% sample (buffer) playback instrument , see default_sampler_ugen_graph. withSc3 (sendMessage (d_recv (defaultSampler False))) audition (defaultSampler False)hsc3 ugen_to_graph of .hsc3Parameter names at . synthdefParam defaultSynthdef == [("amp",0.1),("pan",0),("gate",1),("freq",440),("out",0)]hsc3graph_to_graphdef at .hsc3graph_to_graphdef at .hsc3Encode  as a binary data stream.hsc3Write  to indicated file.hsc3Write / to indicated directory. The filename is the ! with the appropriate extension (scsyndef).hsc3 graph_stat_ln of synth.hsc3 of .hsc3 of . 9synthstat_wr Sound.Sc3.Ugen.Help.Graph.default_ugen_graphhsc3Variant without Ugen sequence. >putStrLn $ synthstat_concise (default_sampler_ugen_graph True)hsc3graphdef_dump_ugens of L Safe-Inferred˥hsc3BUF-NUM must be >= 0hsc3BUF-FRAME-IX must be >= 0hsc3BUF-CHANNEL must be >= 0hsc3BUF-FRAME-CNT must be >= 0hsc3Allocates zero filled buffer to number of channels and samples. (Asynchronous)hsc3;Allocate buffer space and read a sound file. (Asynchronous)hsc3Allocate buffer space and read a sound file, picking specific channels. (Asynchronous)hsc3Close attached soundfile and write header information. (Asynchronous)hsc3Fill ranges of sample values.hsc3 Free buffer data. (Asynchronous)hsc30Call a command to fill a buffer. (Asynchronous)hsc3Call sine1  command.hsc3Call sine2  command.hsc3Call sine3  command.hsc3Call cheby  command.hsc3Call copy  command.hsc3Get sample values.hsc3Get ranges of sample values.hsc3Request /b_info messages.hsc3Read sound file data into an existing buffer. (Asynchronous) Param: bufId pathName startFrame numFrames bufFrame leaveOpenhsc3Read sound file data into an existing buffer, picking specific channels. (Asynchronous)hsc3Set sample values.hsc3Set ranges of sample values.hsc3%Write sound file data. (Asynchronous)hsc3 Zero sample data. (Asynchronous)hsc3Fill ranges of bus values.hsc3Get bus values.hsc3Get ranges of bus values.hsc3Set bus values.hsc3Set ranges of bus values.hsc38Install a bytecode instrument definition. (Asynchronous)hsc3Graphdef encoding variant.hsc3Synthdef encoding variant.hsc3?Load an instrument definition from a named file. (Asynchronous)hsc3Load a directory of instrument definitions files. (Asynchronous)hsc35Remove definition once all nodes using it have ended.hsc35Free all synths in this group and all its sub-groups.hsc3Delete all nodes in a group.hsc3Add node to head of group.hsc3Create a new group.hsc3Add node to tail of group.hsc3Post a representation of a group's node subtree, optionally including the current control values for synths.hsc3Request a representation of a group's node subtree, optionally including the current control values for synths.Replies to the sender with a /g_queryTree.reply message listing all of the nodes contained within the group in the following format: int32 - if synth control values are included 1, else 0 int32 - node ID of the requested group int32 - number of child nodes contained within the requested group For each node in the subtree: [ int32 - node ID int32 - number of child nodes contained within this node. If -1 this is a synth, if >= 0 it's a group. If this node is a synth: symbol - the SynthDef name for this node. If flag (see above) is true: int32 - numControls for this synth (M) [ symbol or int: control name or index float or symbol: value or control bus mapping symbol (e.g. 'c1') ] * M ] * the number of nodes in the subtreeN.Common.Base. The order of nodes corresponds to their execution order on the server. Thus child nodes (those contained within a group) are listed immediately following their parent.hsc3NODE-ID must be >= -1hsc3Place a node after another.hsc3Place a node before another.hsc3'Fill ranges of a node's control values.hsc3Delete a node.hsc3Map a node's controls to read from buses. n_mapn only works if the control is given as an index and not as a name (3.8.0).hsc30Map a node's controls to read from an audio bus.hsc3/Map a node's controls to read from audio buses.hsc3Get info about a node.hsc3Turn node on or off.hsc3Set a node's control values.hsc3Set ranges of a node's control values. n_mapn and n_setn only work if the control is given as an index and not as a name.hsc3 Trace a node.hsc3"Move an ordered sequence of nodes.hsc31Create a new parallel group (supernova specific).hsc3Get control values.hsc3Get ranges of control values.hsc3Create a new synth.hsc3-Auto-reassign synth's ID to a reserved value.hsc3#Send a command to a unit generator.hsc3Send a plugin command.hsc3-Remove all bundles from the scheduling queue.hsc38Select printing of incoming Open Sound Control messages.hsc3!Set error posting scope and mode.hsc39Select reception of notification messages. (Asynchronous)hsc30End real time mode, close file (un-implemented).hsc3Stop synthesis server.hsc3Request /status.reply message.hsc3Request /synced message when all current asynchronous commands complete.hsc3 b_getn1_data fd 0 (0,5))hsc3 Variant of  that segments individual  messages to n elements. 2withSc3 (\fd -> b_getn1_data_segment fd 1 0 (0,5))hsc3 Variant of  that gets the entire buffer.hsc3 of .hsc3"Collect server status information.hsc3#Read nominal sample rate of server.hsc3"Read actual sample rate of server.hsc3!Retrieve status data from server.R Safe-Inferred7hsc39Merge two Nrt scores. Retains internal nrt_end messages.hsc3&Merge a set of Nrt. Retains internal nrt_end messages.hsc3The empty Nrt.hsc30Add bundle at first permissable location of Nrt.hsc3/Add bundle at last permissable location of Nrt.hsc3"bundleTime of last of nrt_bundles.hsc3Delete any internal nrt_end messages, and require one at the final bundle.hsc3Append q to p, assumes last timestamp at p precedes first at q.S Safe-Inferred hsc3$Encode an Osc packet as an Osc blob.hsc38Install a bytecode instrument definition. (Asynchronous)hsc3?Load an instrument definition from a named file. (Asynchronous)hsc3Load a directory of instrument definitions files. (Asynchronous)hsc3Allocates zero filled buffer to number of channels and samples. (Asynchronous)hsc3;Allocate buffer space and read a sound file. (Asynchronous)hsc3Allocate buffer space and read a sound file, picking specific channels. (Asynchronous)hsc3 Free buffer data. (Asynchronous)hsc3Close attached soundfile and write header information. (Asynchronous)hsc3> waitReply "/status.reply")hsc3 of .hsc3 timeout_r of hsc3Run f at k: scsynth servers with sequential port numbers starting at . withSc3AtSeq sc3_default_udp 2 (sendMessage status >> waitReply "/status.reply")hsc3 of .hsc3Free all nodes ( g_freeAll ) at group 1.hsc3Runs  clearSched& and then frees and re-creates groups 1 and 2.hsc3Make s_new message to play .hsc3If the graph size is less than  encode and send using  d_recv_bytes4, else write to temporary directory and read using d_load.hsc3Send d_recv and s_new messages to scsynth.hsc3Send d_recv and s_new messages to scsynth.hsc3Send an  anonymous instrument definition using .hsc3Wait (:) until bundle is due to be sent relative to the initial 6, then send each message, asynchronously if required.hsc3Play an Nrt score (as would be rendered by writeNrt). let sc = Nrt [bundle 1 [s_new0 "default" (-1) AddToHead 1] ,bundle 2 [n_set1 (-1) "gate" 0]] in withSc3 (nrt_play sc)hsc3,Variant where asynchronous commands at time 0 are separated out and run before the initial time-stamp is taken. This re-orders synchronous commands in relation to asynchronous at time 0.hsc3 of .hsc3 of .hsc3 of .hsc3Default , ie. (-1,addToHead,1,[])hsc3 hsc3 hsc3Turn on notifications, run f(, turn off notifications, return result.hsc3 Variant of b_getn1. that waits for return message and unpacks it. %withSc3_tm 1.0 (b_getn1_data 0 (0,5))hsc3 Variant of  that segments individual b_getn messages to n elements. /withSc3_tm 1.0 (b_getn1_data_segment 1 0 (0,5))hsc3 Variant of  that gets the entire buffer.hsc3First channel of , errors if there is no data.  withSc3 (b_fetch1 512 123456789)hsc3Combination of  and .hsc3b_info_unpack_err of b_query1.hsc3Type specialised . withSc3 (b_query1_unpack 0)hsc3 Variant of c_getn1/ that waits for the reply and unpacks the data.hsc3Apply f to result of n_query.hsc3 Variant of n_query& that waits for and unpacks the reply.hsc3 Variant of ' that returns plain (un-lifted) result.hsc3 Variant of  g_queryTree& that waits for and unpacks the reply.hsc3"Collect server status information. &withSc3 serverStatus >>= mapM putStrLnhsc3"Collect server status information. *withSc3 server_status_concise >>= putStrLnhsc3#Read nominal sample rate of server. withSc3 serverSampleRateNominalhsc3"Read actual sample rate of server. withSc3 serverSampleRateActualhsc3!Retrieve status data from server.hsc3%Collect server node tree information. %withSc3 serverTree >>= mapM_ putStrLn44e Safe-Inferred  V Safe-Inferred9hsc3Scsynth state.hsc3.Scsynth with no messages or allocated buffers.hsc3Print onReset messages.hsc37Add a sequence of messages to be sent on scsynth reset. scsynth <- newScsynth scsynthOnReset scsynth [b_free 100] scsynthPrint scsynthhsc3reset scsynth, send all stored onReset messages, clear the onReset message store.hsc3Play Ugen at Scsynth. Send any required initialisation messages and stores and onReset messages.hsc3#scsynthPlayAt with default options.  W Safe-InferredKhsc3!Parameters for recording scsynth.hsc3Sound file format.hsc3Sample format.hsc3 File name.hsc3Number of channels.hsc3 Bus number.hsc3ID of buffer to allocate.hsc3Number of frames at buffer.hsc3ID to allocate for node.hsc3Group to allocate node within.hsc3Recoring duration if fixed.hsc3Default recording structure.hsc3*The name indicates the number of channels.hsc3 Generate " with required number of channels. (Sound.Sc3.Ugen.Dot.draw (rec_synthdef 2)hsc3Asyncronous initialisation s (,  and ). :withSc3 (sendBundle (bundle immediately (rec_init_m def)))hsc3Begin recording  (). 'withSc3 (sendMessage (rec_begin_m def))hsc3End recording s (,  and ). 9withSc3 (sendBundle (bundle immediately (rec_end_m def)))hsc3 score for recorder, if  is given schedule . import Sound.Sc3 withSc3 (Sound.Osc.sendMessage (dumpOSC TextPrinter)) audition (out 0 (sinOsc ar (mce2 440 441) 0 * 0.1)) let rc = default_SC3_Recorder {rec_dur = Just 5.0} nrt_audition (sc3_recorder rc)f Safe-Inferredg Safe-Inferredh Safe-Inferred[ =?>@CABDIHGEFJNMKLORQPSTUVWXYghijklmnopqrstuvwxyz{|}  i Safe-Inferred+j Safe-Inferred- =?>@CABDIHGEFJNMKLORQPSTUVWXYghijklmnopqrstuvwxyz{|}  klmnopqrstuvwxyz{|}~[\    \                   \                           !"""""""""""""######$$$%%%%%%%%%%%%%%%%&&&&&&&&&'''(((((((()))))))))))))))))))))))))))))))))))))))*************** * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + + + + + + + , , , , , , , , - - - - - . . . . . . . . . .... . .. . . . . . . . . . . . . / / / / / / / / / 00 0 0 0 0 0 0 00 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 2 2 2 2 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 4 4 5 5 6 6 6 6 6 6 7 7 7 7 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 9 9 9 : : : : : : : : : : : : : ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<<<<<=================== === =============================================================================================================================================================================== = ========================================================== = = ======== ======================================================================================================== =============================== ============= ==========================================================>>>>>>??????@@@@@@@@@@@@@@@@@@AAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBCCCCCCDDDDDDDDDDDDDDDEEEEEEFFFFFFFFFGGGGGGGGGGGGGGGGGGGGHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIIIIIIIIIIIJJJJKKKKKKKKKKKKKKKKKKKKKLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLcLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMcMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNOOOOOOOOOOOOOOOOOOOPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRSSSSSSSSSSSSSTTTTTUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVVVVVVVVVWWWWWWWWWWWWWWWWWWWX  hsc3-0.20-FOBvVn4puwXJxPgf7RqM5SSound.Sc3.Common.BaseSound.Sc3.Common.Base.SystemSound.Sc3.Common.ContextSound.Sc3.Common.EnumSound.Sc3.Common.HelpSound.Sc3.Common.Help.Sc2Sound.Sc3.Common.MathSound.Sc3.Common.BufferSound.Sc3.Common.Buffer.VectorSound.Sc3.Common.Buffer.GenSound.Sc3.Common.Buffer.ArraySound.Sc3.Common.Math.Filter Sound.Sc3.Common.Math.Filter.Beq!Sound.Sc3.Common.Math.InterpolateSound.Sc3.Common.EnvelopeSound.Sc3.Common.Math.NoiseSound.Sc3.Common.Math.OperatorSound.Sc3.Common.Math.WarpSound.Sc3.Common.Math.WindowSound.Sc3.Common.MceSound.Sc3.Common.Monad Sound.Sc3.Common.Monad.OperatorsSound.Sc3.Common.RandomSound.Sc3.Common.RateSound.Sc3.Common.SoundFileSound.Sc3.Common.UidSound.Sc3.Common.UnsafeSound.Sc3.Server.Command.EnumSound.Sc3.Server.EnumSound.Sc3.Server.Graphdef Sound.Sc3.Server.Graphdef.BinarySound.Sc3.Server.Graphdef.TextSound.Sc3.Server.Graphdef.IoSound.Sc3.Server.NrtSound.Sc3.Server.Nrt.RenderSound.Sc3.Server.Nrt.StatSound.Sc3.Server.OptionsSound.Sc3.Server.ParamSound.Sc3.Ugen.BracketsSound.Sc3.Ugen.ConstantSound.Sc3.Ugen.ControlSound.Sc3.Ugen.HsSound.Sc3.Ugen.LabelSound.Sc3.Ugen.MrgSound.Sc3.Ugen.NameSound.Sc3.Ugen.PrimitiveSound.Sc3.Ugen.ProxySound.Sc3.Ugen.UgenSound.Sc3.Ugen.PpSound.Sc3.Ugen.Plain$Sound.Sc3.Ugen.Bindings.Hw.ConstructSound.Sc3.Ugen.Enum(Sound.Sc3.Ugen.Bindings.Hw.External.Zita,Sound.Sc3.Ugen.Bindings.Hw.External.Wavelets&Sound.Sc3.Ugen.Bindings.Hw.External.F0Sound.Sc3.Ugen.UtilSound.Sc3.Ugen.Math.CompositeSound.Sc3.Ugen.Bindings.Hw#Sound.Sc3.Ugen.Bindings.Db.External/Sound.Sc3.Ugen.Bindings.Hw.External.Sc3_PluginsSound.Sc3.Ugen.Bindings.DbSound.Sc3.Ugen.OptimiseSound.Sc3.Ugen.MathSound.Sc3.Ugen.MceSound.Sc3.Ugen.AnalysisSound.Sc3.Ugen.GraphSound.Sc3.Ugen.Graph.Transform Sound.Sc3.Ugen.Graph.ReconstructSound.Sc3.Server.Graphdef.ReadSound.Sc3.Server.Graphdef.Graph*Sound.Sc3.Ugen.Bindings.Composite.External!Sound.Sc3.Ugen.Bindings.CompositeSound.Sc3.Ugen.EventSound.Sc3.Ugen.Help.GraphSound.Sc3.Server.Synthdef Sound.Sc3.Server.Command.GenericSound.Sc3.Server.Command.PlainSound.Sc3.Ugen.BracketedSound.Sc3.Server.StatusSound.Sc3.Server.Nrt.UgenSound.Sc3.Server.Transport.FdSound.Sc3.Server.Nrt.Edit#Sound.Sc3.Server.Command.CompletionSound.Sc3.Ugen.Envelope Sound.Sc3.Server.Transport.MonadSound.Sc3.Server.ScsynthSound.Sc3.Server.Recorder Text.Read readMaybeC blendAtByresamp1Sound.Sc3.CommonSystem.Process callProcessSound.Sc3.Ugen.Types#Sound.Sc3.Ugen.Bindings.Hw.ExternalSound.Sc3.Server.Commandu_cmdSound.Sc3.Ugen.BindingsSound.Sc3.UgenSound.Sc3.ServerSound.Sc3.Server.Monad Sound.Sc3Sound.Sc3.Server.Fd Sound.Sc3.FdT4T3T2 Case_RuleCiCsSciFn11Fn10Fn6Fn5Fn4Fn3Fn2Fn1iterfvoid reads_exactstring_split_at_char string_eq rlookup_str parse_enum compose_l compose_rd_dxd_dx'dx_ddx_d' lookup_by lookup_by_err rlookup_by pcn_triples sep_firstsep_lastequal_length_p histogramat_with_error_messageconcat_intersperselist_split_at_elemsort_on insertBy_post insert_postat_lastp4_zipdup2dup3dup4 mk_duples mk_duples_l mk_triples t2_from_list t3_from_list $fEqCase_Ruleget_env_with_defaultget_env_defaultlookup_env_defaultContextcontext_format context_write min_context std_contextBuffer Buffer_IdWarpLinear ExponentialWithWarp DoneAction DoNothing PauseSynth RemoveSynth RemoveGroupWithDoneAction InterpolationNoInterpolationLinearInterpolationCubicInterpolationWithInterpolationLoopNoLoopWithLooploop_map from_loopfrom_interpolationdone_action_mapfrom_done_action from_warpwarp_map $fFunctorLoop$fFunctorDoneAction $fFunctorWarp $fEqBuffer $fShowBuffer$fEqWarp $fShowWarp$fEqDoneAction$fShowDoneAction$fEqInterpolation$fShowInterpolation$fEqLoop $fShowLoopsc3_rtf_help_dirsc3_rtf_find_filesc3_rtf_find_file_errsc3_rtf_to_scdsc3_rtf_help_translatesc3_rtf_help_scd_opensc3_rtf_help_scd_open_emacssc3_scdoc_help_urlsc3_scdoc_help_dirsc3_scdoc_help_classsc3_scdoc_help_operatorsc3_scdoc_help_methodsc3_scdoc_help_class_methodsc3_scdoc_help_instance_methodsc3_scdoc_help_pathsc3_scdoc_help_open"sc3_scdoc_help_server_command_path"sc3_scdoc_help_server_command_open on_lines_ofsplit_multiple_fragmentsdrop_post_graph_sectionread_file_fragmentsread_file_set_fragmentssc2_ugen_categories Clip_Rule Clip_None Clip_Left Clip_Right Clip_Both SC3_MulAddhalf_pitwo_piabsdif sc3_mul_addmul_add mul_add_hs sc3_truncate sc3_round sc3_ceiling sc3_floor sc3_round_tosc3_idivsc3_lcmsc3_gcdsc3_modfmod_f32fmod_f64sc3_clipclip_hs sc3_mod_alt sc3_wrap_ni wrap_hs_intwrap_hssc3_wrap generic_wrap bin_to_freq midi_to_cps cps_to_midi cps_to_oct oct_to_cps degree_to_keypianokey_to_midipianokey_to_cps amp_to_db db_to_amp midi_to_ratio ratio_to_midi cps_to_incr incr_to_cpspan2_flin_pan2eq_pan2sc3_properFraction sc3_dif_sqr sc3_hypot sc3_hypotx foldToRangesc3_fold sc3_distort sc3_softclipsc3_true sc3_falsesc3_notsc3_boolsc3_comparisonsc3_eqsc3_neqsc3_ltsc3_ltesc3_gtsc3_gteapply_clip_rule urange_maurange range_muladdrange_marangerange_hsin_range linlin_muladd linlin_ma linlin_hs sc3_linlinlinlin_enum_plain linlin_enumlinlin_enum_err linlin_eq linlin_eq_err linexp_hslin_exp sc3_linexp sc3_explin sc3_expexp sc3_lincurve sc3_curvelin double_pp_rm0 double_ppreal_pp parse_double sum_opt_fsin_taylor_approximationsin_bhaskara_approximationsin_green_approximationsin_adenot_approximationsin_robin_approximation$fEnumClip_Rule$fBoundedClip_RuleblendclipAtblendAt resamp1_gen normalizeSum normalise_rng normalize t2_window t2_adjacent t2_overlap t2_concatfrom_wavetable to_wavetableto_wavetable_nowrapsineGensineFillsum_lnrm_usine1_psine1_lsine1 sine1_nrmsine1Tblsine2_lsine2 sine2_nrmsine3_psine3_lsine3 gen_chebychebychebyShaperTbl Pinking_ParamIir2CoefSosCoefbw_lpf_or_hpf_coef rlpf_coef resonz_coefpinking_filter_freq_48000pinking_filter_freq_96000pinking_filter_freq_192000pinking_filter_coefpinking_filter_next bLowPassCoef bHiPassCoef bAllPassCoef bBandPassCoef bBandStopCoef bPeakEQCoef bLowShelfCoef bHiShelfCoefInterpolation_f interpolatesteplinear exponential exponential_0exponential_linsinewelchcurvesquaredcubedholdfaderAsrasr_attackTimeasr_sustainLevelasr_releaseTime asr_curveAdssradssr_attackTimeadssr_attackLeveladssr_decayTimeadssr_decayLeveladssr_slopeTimeadssr_sustainLeveladssr_releaseTime adssr_curve adssr_biasAdsradsr_attackTimeadsr_decayTimeadsr_sustainLeveladsr_releaseTimeadsr_peakLevel adsr_curve adsr_biasLinenlinen_attackTimelinen_sustainTimelinen_releaseTime linen_level linen_curveEnvelope_SegmentEnvelope env_levels env_times env_curvesenv_release_node env_loop_node env_offsetEnvelope_Curve_4Envelope_Curve_3Envelope_Curve_2Envelope_CurveEnvStepEnvLinEnvExpEnvSinEnvWelchEnvNumEnvSqrEnvCubEnvHoldenv_curve_shapeenv_curve_valueenv_curve_interpolation_f env_curve_map envelope_mapenvelopeenvelope_durationenvelope_n_segmentsenvelope_segment_ixenvelope_segmentenvelope_segmentspack_envelope_segmentsenvelope_is_normalenvelope_normalise envelope_atenvelope_renderenvelope_tableenvelope_curvesenvelope_sc3_arrayenvelope_sc3_ienvgen_arrayenv_is_sustained env_delay env_circle_z env_circle_0envTrapezoid_fenvCoordenvPairs envPerc_cenvPerc envTriangleenvSine linen_def envLinen_r envLinen_cenvLinenadsr_defenvAdsr envAdsr_def envAdsr_renvAdssr envAdssr_rasr_defenvAsr_cenvAsrenvAsr_renvStepenvXyc envXyc_sort$fFunctorEnvelope $fEqEnvelope$fShowEnvelope$fEqEnvelope_Curve$fShowEnvelope_Curvecusp_ffbSine_fhenon_flatoocarfian_f linCong_f logistic_florenz_fquad_f standard_fBinaryOpabsDifamClipatan2Eclip2difSqrexcess exprandRangefillfirstArgfold2gcdEhypothypotxiDivlcmEmodE randRangering1ring2ring3ring4roundUpscaleNegsqrDifsqrSumsumSqrthreshtruncwrap2UnaryOpampDbasFloatasIntcpsMidicpsOctdbAmpdistortfracisNillog10log2midiCps midiRationotEnotNiloctCpsramp_ ratioMidisoftClip RealFracEproperFractionE truncateEroundEceilingEfloorEOrdE less_thanless_than_or_equal_to greater_thangreater_than_or_equal_toEqEequal_to not_equal_to Sc3_Binary_OpOpAddOpSubOpMulOpIdivOpFdivOpModOpEqOpNeOpLtOpGtOpLeOpGeOpMinOpMaxOpBitAndOpBitOrOpBitXorOpLcmOpGcd OpRoundTo OpRoundUpOpTruncOpAtan2OpHypotOpHypotxOpPow OpShiftLeft OpShiftRightOpUnsignedShiftOpFillOpRing1OpRing2OpRing3OpRing4OpDifSqrOpSumSqrOpSqrSumOpSqrDifOpAbsDifOpThreshOpAmClip OpScaleNegOpClip2OpExcessOpFold2OpWrap2 OpFirstArg OpRandRangeOpExpRandRange Sc3_Unary_OpOpNegOpNotOpIsNilOpNotNilOpBitNotOpAbs OpAsFloatOpAsIntOpCeilOpFloorOpFracOpSign OpSquaredOpCubedOpSqrtOpExpOpRecip OpMidiCps OpCpsMidi OpMidiRatio OpRatioMidiOpDbAmpOpAmpDbOpOctCpsOpCpsOctOpLogOpLog2OpLog10OpSinOpCosOpTanOpArcSinOpArcCosOpArcTanOpSinhOpCoshOpTanhOpRand_OpRand2 OpLinRand_ OpBiLinRand OpSum3Rand OpDistort OpSoftClipOpCoin OpDigitValue OpSilenceOpThru OpRectWindow OpHanWindow OpWelchWindow OpTriWindowOpRamp_OpScurvesc3_unary_op_name parse_unarysc3_unary_op_tbl unary_sym_tbl unaryName unaryIndexis_unarysc3_binary_op_namesc3_binary_op_tbl parse_binarybinary_sym_tblsc3_binary_op_sym_tbl binaryName binaryIndex is_binaryugen_operator_nameresolve_operatorresolve_operator_ci==**/=**<**<=**>**>=** binop_hs_tblbinop_special_hs uop_hs_tbluop_special_hs $fEqEDouble $fEqEFloat $fEqEInt64 $fEqEInt32 $fEqEInteger$fEqEInt $fOrdEDouble $fOrdEFloat $fOrdEInt64 $fOrdEInt32 $fOrdEInteger $fOrdEInt$fRealFracEDouble$fRealFracEFloat$fUnaryOpDouble$fUnaryOpFloat$fBinaryOpDouble$fBinaryOpFloat$fEqSc3_Binary_Op$fShowSc3_Binary_Op$fEnumSc3_Binary_Op$fBoundedSc3_Binary_Op$fReadSc3_Binary_Op$fEqSc3_Unary_Op$fShowSc3_Unary_Op$fEnumSc3_Unary_Op$fBoundedSc3_Unary_Op$fReadSc3_Unary_OpWarp_fwarp_lin warp_lin_invwarp_exp warp_exp_invwarp_cos warp_cos_invwarp_sin warp_sin_invwarp_amp warp_amp_invwarp_db warp_db_inv warp_curvewarp_curve_inv warp_named TableFormat TableClosed TableOpen TableGuardedTableWindow window_tablewindow_table_closedsquaregaussianhannhamming rectangular triangulargaussian_table hamming_table hann_table sine_tabletriangular_table$fEqTableFormat$fShowTableFormatMce Mce_Scalar Mce_Vectormce_is_well_formed mce_is_scalar mce_from_list mce_to_listmce_showmce_scalar_value mce_length mce_depth mce_extendmce_map mce_binop $fFloatingMce$fFractionalMce$fNumMce $fFunctorMce$fOrdMce$fEqMce $fReadMce $fShowMcerepeatMmvoidrepeatM_composeMchainM.++..+..**..*..--..-..//../.lcglcgWord64Knuth lcgInt32GlibccpuTimeSeedWord64cpuTimeSeedInt32lcgWord64KnuthCpuTimeword64ToUnitDoublelcgDoubleKnuthCpuTimeK_TypeK_InitialisationRate K_ControlRate K_TriggerRate K_AudioRateRateInitialisationRate ControlRate AudioRate DemandRateirkrardr rateAbbrevrateNamerateId rate_color all_rates rate_parsektype $fEqK_Type $fShowK_Type $fOrdK_Type$fEqRate $fOrdRate $fEnumRate $fBoundedRate $fShowRate $fReadRatefindFileFromDirectoryfindFileAtOrFromDirectoryfindFileAtOrFromPathsfDirsfPath sfFindFile sfResolveFile sfResolve sfNumChannels sfSampleRate sfFrameCount sfMetadatasfInfoID resolveIDUid_StUid generateUidId uid_id_eval uid_st_eval uid_st_seq uid_st_seq_liftUid1liftUid2liftUid3liftUid4liftUid5liftUid6 liftUid10 liftUid11id_seq $fUidReaderT$fUidIO $fUidStateT$fID(,,)$fID(,)$fIDInt$fIDChar liftUnsafe0 liftUnsafe1 liftUnsafe2 liftUnsafe3 liftUnsafe4 liftUnsafe5 liftUnsafe6 liftUnsafe7 liftUnsafe8 liftUnsafe9 liftUnsafe10 liftUnsafe11 liftUnsafe12 SC3_Commandsc3_cmd_enumerationsc3_cmd_number known_sc3_cmd async_cmdsisAsyncpartition_async b_info_fields n_info_fields SampleFormatPcmInt8PcmInt16PcmInt24PcmInt32PcmFloat PcmDoublePcmMulawPcmAlawSoundFileFormatAiffFlacIrcamNextRawWave PrintLevel NoPrinter TextPrinter HexPrinter AllPrinter ErrorMode ErrorsOffErrorsOn ErrorScopeGloballyLocallyB_Gen Normalise WavetableClear AddAction AddToHead AddToTail AddBeforeAddAfter AddReplace b_gen_bit b_gen_flagsoundFileFormatStringsoundFileFormat_from_extension"soundFileFormat_from_extension_errsampleFormatString$fEnumSampleFormat$fEqSampleFormat$fReadSampleFormat$fShowSampleFormat$fEnumSoundFileFormat$fEqSoundFileFormat$fReadSoundFileFormat$fShowSoundFileFormat$fEqPrintLevel$fShowPrintLevel$fEnumPrintLevel $fEqErrorMode$fShowErrorMode$fEnumErrorMode$fEqErrorScope$fShowErrorScope$fEnumErrorScope $fEqB_Gen $fEnumB_Gen$fBoundedB_Gen $fShowB_Gen $fEqAddAction$fShowAddAction$fEnumAddActionEncode_Functions Get_FunctionsGraphdef graphdef_namegraphdef_constantsgraphdef_controlsgraphdef_ugensUgenSpecialOutputInput Port_Index Ugen_IndexSampleControlNameconstant_index ugen_name_str ugen_name_op ugen_rateugen_rate_enum ugen_inputs ugen_outputsugen_is_controlinput_is_control graphdef_ugengraphdef_controlgraphdef_constant_nidgraphdef_control_nidgraphdef_ugen_nidscgf_i32 get_control get_inputget_ugen get_graphdefencode_input_fencode_control_f encode_ugen_fencode_graphdef_f graphdef_statugen_dump_ugen_strgraphdef_dump_ugens_strgraphdef_dump_ugens $fEqGraphdef$fShowGraphdef $fEqInput $fShowInputget_pstr binary_get_fread_graphdef_file scsyndef_statenc_bytestring encode_pstr encode_inputencode_control encode_ugen encode_sampleencode_graphdef graphdefWritegraphdefWrite_dir print_stringenc_textprint_graphdef list_read_f read_float text_get_f read_graphdefNrt nrt_bundles oscWithSizenrt_span encodeNrtwriteNrtputNrtdecode_nrt_bundles decodeNrtreadNrtnrt_non_ascending $fShowNrtNrt_Render_PlainNrt_Param_Plainnrt_param_plain_to_argnrt_exec_plainnrt_proc_plainnrt_render_plainNrt_Statnrt_stat_paramnrt_stat Sc3_ProtocolSc3_UdpSc3_TcpSc3_Opt sc3_opt_value sc3_addr_def sc3_port_defsc3_opt_port_def sc3_opt_defsc3_opt_def_udp sc3_opt_bool sc3_opt_get sc3_opt_set sc3_opt_edit sc3_opt_arg sc3_opt_cmdParamParam1 param_insertparam_merge_uniq param_merge_rparam_merge_r_seq param_get param_parseparam_ppBrackets emptyBracketsconcatBracketsConstant constantValueconstantBrackets $fOrdConstant $fEqConstant$fReadConstant$fShowConstantcontrolOperatingRate controlIndex controlNamecontrolDefaultcontrolTriggered controlMetacontrolBracketsControl_Meta_T5Control_Meta_T3 Control_Metactl_minctl_maxctl_warpctl_step ctl_units controlGroup Control_Group Control_Range Control_Array Control_Xycontrol_group_degreecontrol_group_suffixescontrol_meta_t3control_meta_t5 $fOrdControl $fEqControl $fReadControl $fShowControl$fOrdControl_Meta$fEqControl_Meta$fReadControl_Meta$fShowControl_Meta$fOrdControl_Group$fEqControl_Group$fReadControl_Group$fShowControl_GroupT9T8T7T6T5F_U9F_U8F_U7F_U6F_U5F_U4F_U3F_U2F_ST1F_ST0avg2avg3avg4avg5avg9fir1fir2fir3fir4fir8iir1iir2 iir2_ff_fbbiquadsos_fsoshpz1hpz2lpz1lpz2bpz2brz2mavg5mavg9 sr_to_rpsresonz_f resonz_irrlpf_frlpf_ir bw_hpf_ir bw_lpf_ir white_noise brown_noise_f brown_noisepk_pinking_filter_fpk_pinking_filter_economy_fdecay_f lag_f_frameslag_flagslopelatchas_trigphasormod_dif l_apply_f_st0 l_white_noise l_brown_noise l_apply_f_st1l_lagl_slopel_phasor l_phasor_osc l_sin_osc l_cos_oscl_hpz1l_hpz2l_lpz1l_lpz2l_bpz2l_brz2l_bw_hpfl_bw_lpf l_resonz_ir l_rlpf_irl_mavg5l_mavg9Label ugenLabel $fOrdLabel $fEqLabel $fReadLabel $fShowLabelMrgmrgLeftmrgRight$fOrdMrg$fEqMrg $fReadMrg $fShowMrgsc3_name_edges_plainsc3_name_edgessc3_name_to_hs_namesc3_name_to_lisp_namesc3_ugen_name_sep PrimitiveugenRateugenName ugenInputs ugenOutputs ugenSpecialugenIdprimitiveBracketsUgenIdNoIdno_id$fOrdPrimitive $fEqPrimitive$fReadPrimitive$fShowPrimitive $fOrdSpecial $fEqSpecial $fReadSpecial $fShowSpecial $fOrdUgenId $fEqUgenId $fReadUgenId $fShowUgenIdProxy proxySource proxyIndex proxyRate $fOrdProxy $fEqProxy $fReadProxy $fShowProxy Constant_U Control_ULabel_U Primitive_UProxy_UMce_UMrg_Uugen_user_nameroundToparse_constant un_constant u_constantu_constant_errmrg mrg_leftmost isConstantisSinkun_proxyisProxy ugenPrimitive isPrimitivemce mceProxiesisMce mceChannels mceDegree mceDegree_err mceExtend mceRequiredmceInputTransformmceBuildmce_is_direct_proxy bracketUgen ugenBrackets checkInputconstant int_to_ugen float_to_ugendouble_to_ugenproxyrateOfproxifymk_ugen_select_ratemkUgen mkOperatormkUnaryOperator#mkBinaryOperator_optimise_constantsmkBinaryOperatoris_primitive_foris_constant_of is_math_binopis_add_operatorassert_is_add_operatoris_mul_operatormul_add_optimise_directmul_add_optimisesum3_optimise_direct sum3_optimise add_optimise $fBitsUgen $fRandomUgen $fEnumUgen $fOrdUgen$fRealFracUgen$fIntegralUgen $fRealUgen$fFloatingUgen$fFractionalUgen $fNumUgen$fBinaryOpUgen $fUnaryOpUgen$fRealFracEUgen $fOrdEUgen $fEqEUgen$fEqUgen $fReadUgen $fShowUgenugen_concise_ppmk_plainuopbinopugennondetmk_oscmkOscmkOscRmkOscIdRmkOscId mk_osc_mcemkOscMCE mkOscMCEId mk_filter mkFilterIdR mkFilterRmkFilter mkFilterId mk_filter_mce mkFilterMCER mkFilterMCE mkFilterMCEIdmkInfoEnvCurve from_buffer zitaRev_paramzitaRevdwtidwt wt_MagAbovewt_FilterScale wt_TimeWipewt_Mul atari2600mzPokey redPhasor redPhasor2toUid ugenTraverse ugenFoldrugenCollectBracketsugenHasAnyBrackets control_f64control control_m control_pair control_rngtrigControl_f64 trigControl control_setmce1mce2mce2cunmce2mce3unmce3mceMapmap_ix mce_map_ixmceEdit mceReverse mceChannelmceChannelWrap mceTranspose mceRotate mceConcatmceClump mceReduce mceProducthalt_mce_transform_fhalt_mce_transform prepare_rootmrg2label unpackLabelenvelope_to_ugenenvelope_to_ienvgen_ugenbitAndbitOrbitXOrbitNot shiftLeft shiftRight unsignedShift.<<..>>.rewriteUgenRatesrewriteToControlRaterewriteToDemandRaterewriteToInitialisationRate rewriteToRateugen_if"ugen_integral_and_fractional_partsugen_fmidi_to_midi_detuneclearBufdwrandIddwrandMdwrand envGen_ll fftTriggerpackFFTpollpv_HainsworthFootepv_JensenAndersenstring_to_ugens sendReply unpack1FFTa2bayay8910allpass1allpass2 amplitudeModanalogBassDrum analogFoldOsc analogPhaseranalogPhaserModanalogPulseShaperanalogSnareDrum analogTapeanalogVintageDistortionanalyseEvents2arneodoCoulletTresserarrayMaxarrayMin astrocadeatsAmpatsBandatsFreq atsNoiSynthatsNoise atsParInfo atsPartialatsSynth attackSlopeaudioMSG averageOutputb2ab2Sterb2uhj bBlockerBuf bfDecode1 bfDecoder bfEncode1 bfEncode2 bfEncodeSter bfGrainPanner bfManipulatebfPannerblBufRdblOscbMoogbalancebeatStatisticsbeepbeepUbinDatablitB3blitB3D blitB3Saw blitB3Square blitB3Tri breakcore brusselatorbufGrain bufGrainB bufGrainBBF bufGrainBF bufGrainI bufGrainIBFbufMaxbufMincq_Diffcepstrumchen chromagram circleRamp clipper32clipper4clipper8clockmuscombLP complexResconcatconcat2coyotecrestcrossoverDistortion dCompressordfm1 dNoiseRingId dNoiseRingM dNoiseRingdpw3Tridpw4SawdwgBoweddwgBowedSimple dwgBowedTor dwgClarinet3dwgFlute dwgPlucked dwgPlucked2dwgPluckedStiff dwgSoundBoarddbrown2 dbufTagIddbufTagMdbufTag decimatordetaBlockerBufIddetaBlockerBufMdetaBlockerBufdfsmIddfsmMdfsmdgauss diodeRingModdisintegratorIddisintegratorM disintegratordneuromoduleId dneuromoduleM dneuromoduledoubleNestedAllpassCdoubleNestedAllpassLdoubleNestedAllpassN doubleWell doubleWell2 doubleWell3 driveNoise drumTrackdtag envDetect envFollow fftComplexDevfftCrest fftDiffMagsfftFlux fftFluxPosfftmklfftPeak fftPhaseDevfftPowerfftSlope fftSpreadfftSubbandFlatnessfftSubbandFluxfftSubbandPowerfm7fmGrainfmGrainB fmGrainBBF fmGrainBFfmGrainI fmGrainIBF fmhDecode1 fmhEncode0 fmhEncode1 fmhEncode2 featureSavefhn2DCfhn2DLfhn2DNfhnTrig fincoSprottL fincoSprottM fincoSprottSfitzHughNagumo frameComparefriction gammatone gaussClass gaussTriggbman2DCgbman2DLgbman2DN gbmanTriggendy4gendy5getenv glitchBPF glitchBRF glitchHPF glitchRHPFgoertzel grainBufJgrainFMJgrainInJ grainSinJ gravityGrid gravityGrid2 greyholeRawhairCell harmonicOschenon2DChenon2DLhenon2DN henonTrig iCepstrum iirFilterinGraininGrainB inGrainBBF inGrainBFinGrainI inGrainIBF insideOut instruction jPverbRawkMeansRT keyClaritykeyModekmeansToBPSet1lfBrownNoise0IdlfBrownNoise0M lfBrownNoise0lfBrownNoise1IdlfBrownNoise1M lfBrownNoise1lfBrownNoise2IdlfBrownNoise2M lfBrownNoise2 lpcAnalyzerlpcErrorlpcSynthlpcValslpf1lpf18lpfvs6lpgltilatoocarfian2DClatoocarfian2DLlatoocarfian2DNlatoocarfianTriglistTrig listTrig2loggerloopBuf lorenz2DC lorenz2DL lorenz2DN lorenzTriglores lotkaVolterra mcldChaosGen markovSynth matchingPmatchingPResynthmaxmaxampmdaPiano meanTriggeredmeddismedianSeparationmedianTriggeredmembraneCirclemembraneHexagonmetromiBraidsmiClouds miElementsmiGridsmiMumiOmimiPlaitsmiRings miRipplesmiTidesmiVerbmiWarps monoGrain monoGrainBF moogLaddermoogVCFnhHallnlnl2nlFiltCnlFiltLnlFiltNnTubenearestN needleRect neoFormant neoVarSawOscnes2nestedAllpassCnestedAllpassLnestedAllpassNosFold4osFold8osTrunc4osTrunc8osWrap4osWrap8onsetStatistics oregonatoroscBank oteyPianooteyPianoStringsoteySoundBoardpvInfopvSynth pv_BinBufRd pv_BinDelay pv_BinFilter pv_BinPlayBufpv_BufRd pv_CommonMag pv_CommonMul pv_Compander pv_Cutoff pv_EvenBinpv_ExtractRepeat pv_Freeze pv_FreqBuffer pv_Invert pv_MagBuffer pv_MagExp pv_MagGate pv_MagLog pv_MagMap pv_MagMinus pv_MagMulAdd pv_MagScale pv_MagSmoothpv_MagSubtract pv_MaxMagN pv_MinMagNpv_Morphpv_NoiseSynthFpv_NoiseSynthP pv_OddBinpv_PartialSynthFpv_PartialSynthP pv_PitchShift pv_PlayBuf pv_RecordBuf pv_SoftWipepv_SpectralEnhancepv_SpectralMappv_Split pv_Whitenpv_xFadepanXpanX2DpeakEQ2peakEQ4perlin3permMod permModArraypermModT phasorModal planeTreepokeyposRatioprintValqitchbezierrcdrdldx7rdx7Env rDelayMap rDelaySet rDelaySetBuf dustRangeId expRandNId expRandNMexpRandNfreezeriRandNIdiRandNMiRandNrlpfdrLagC linRandNId linRandNMlinRandNrLoopSet rmaFoodChainLrmeq rmeqSuitermsrmShelfrmShelf2 obxdFilter rpvDecayTblrandNIdrandNMrandNsvfBpsvfHpsvfLp shufflerB rShufflerL rSmplrIndex tExpRandNId tExpRandNM tExpRandN tLinRandNId tLinRandNM tLinRandNtRandNIdtRandNMtRandN tScrambleId tScrambleM tScramble rTracePlayrTraceRd redDPCMdecode redDPCMencoderedLbylredNoiseregaliaMitraEQ resonatorrongsrosslerL rosslerResLrotatesid6581fslOnsetsmssn76489 somAreaWrsomRdsomTrainsvfsawDPWsensoryDissonancesieve1sinGrain sinGrainB sinGrainBBF sinGrainBF sinGrainI sinGrainIBFsinTone sineShaper skipNeedleslideslubsmoothDecimator softClipAmp softClipAmp4 softClipAmp8 softClipper4 softClipper8sonLPC sonLPCSynth sonLPCSynthInsortBufspectralEntropyspreader spruceBudwormsquiz standard2DC standard2DL standard2DN standardTrig stkBandedWG stkBeeThree stkBlowHolestkBowed stkClarinetstkFlute stkGlobalsstkInst stkMandolin stkModalBarstkMoogstkPluck stkSaxofony stkShakers stkVoicFormstreson stringVoicesummer switchDelay tBetaRandId tBetaRandM tBetaRand tBrownRandId tBrownRandM tBrownRand tGaussRandId tGaussRandM tGaussRandtGrains2tGrains3tpv tTendencytartini termanWangtextVUtilttrigAvgtumbletwoTubeuhj2bvbap vbChebyFilt vbFourses vbJonVerbvbpVocvbSlidevmScan2Dvosim varShapeOscvosimOscwAmp walshHadamardwarpZwaveLoss waveTerrain waveletDaubweaklyNonlinearweaklyNonlinear2werner wrapSummerzOsc ayFreqToToneladspastkAt stkBowedI binaryOpUgen unaryOpUgena2kapfallpassCallpassLallpassNampCompampCompA amplitudebAllPass bBandPass bBandStopbHiPassbHiShelfbLowPass bLowShelfbpfbPeakEQbrfbalance2ball beatTrack beatTrack2biPanB2blip blockSize brownNoiseId brownNoiseM brownNoise bufAllpassC bufAllpassL bufAllpassN bufChannelsbufCombCbufCombLbufCombN bufDelayC bufDelayL bufDelayNbufDur bufFrames bufRateScalebufRd bufSampleRate bufSamplesbufWrcOsccheckBadValuesclip clipNoiseId clipNoiseM clipNoise coinGateId coinGateMcoinGatecombCcombLcombN compander companderD controlDur controlRate convolution convolution2 convolution2L convolution3cracklecuspLcuspNdcdbrownIddbrownMdbrowndbufrdIddbufrdMdbufrddbufwrIddbufwrMdbufwrdconstIddconstMdconstdecaydecay2decodeB2 degreeToKeydelTapRddelTapWrdelay1delay2delayCdelayLdelayNdemand demandEnvGen detectIndex detectSilencedgeomIddgeomMdgeom dibrownIddibrownMdibrowndiskIndiskOut diwhiteIddiwhiteMdiwhitedonedpollIddpollMdpolldrandIddrandMdranddresetIddresetMdresetdseqIddseqMdseqdserIddserMdser dseriesIddseriesMdseriesdshufIddshufMdshuf dstutterId dstutterMdstutter dswitchIddswitchMdswitch dswitch1Id dswitch1Mdswitch1 duniqueIdduniqueMduniquedustIddustMdustdust2Iddust2Mdust2dutydwhiteIddwhiteMdwhitedxrandIddxrandMdxrandenvGen expRandIdexpRandMexpRandfbSineCfbSineLfbSineNfftfosfSinOscfoldformantformletfreefreeSelffreeSelfWhenDonefreeVerb freeVerb2 freqShiftgVerbgategbmanLgbmanNgendy1Idgendy1Mgendy1gendy2Idgendy3Idgendy3Mgendy3grainBufgrainFMgrainIngrainSin grayNoiseId grayNoiseM grayNoisehpfhasherhenonChenonLhenonNhilbertiEnvGenifftiRandIdiRandMiRandimpulsein' inFeedbackinRangeinRectinTrigindexindexInBetweenindexL infoUgenBase integratork2akeyStatekeyTrackklangklank lfClipNoiseId lfClipNoiseM lfClipNoiselfCublfdClipNoiseId lfdClipNoiseM lfdClipNoise lfdNoise0Id lfdNoise0M lfdNoise0 lfdNoise1Id lfdNoise1M lfdNoise1 lfdNoise3Id lfdNoise3M lfdNoise3lfGauss lfNoise0Id lfNoise0MlfNoise0 lfNoise1Id lfNoise1MlfNoise1 lfNoise2Id lfNoise2MlfNoise2lfParlfPulselfSawlfTrilpflag2lag2UDlag3lag3UDlagInlagUD lastValue latoocarfianC latoocarfianL latoocarfianNleakDC leastChangelimiterlinCongClinCongLlinCongNlinExplinPan2 linRandIdlinRandMlinRand linXFade2linelinen localBufId localBufMlocalBuflocalInlocalOutlogisticlorenzLloudnessmfcc mantissaMaskmedianmidEQmodDifmoogFF mostChange mouseButtonmouseXmouseYnRandIdnRandMnRandnodeID normalizer numAudioBuses numBuffersnumControlBuses numInputBusesnumOutputBusesnumRunningSynths offsetOutonePoleoneZeroonsetsoscoscNout pSinGrainpv_Addpv_BinScrambleIdpv_BinScrambleMpv_BinScramble pv_BinShift pv_BinWipe pv_BrickWallpv_ConformalMappv_Conjpv_Copy pv_CopyPhase pv_Diffuserpv_Div pv_LocalMax pv_MagAbove pv_MagBelow pv_MagClip pv_MagDiv pv_MagFreeze pv_MagMul pv_MagNoise pv_MagShift pv_MagSmear pv_MagSquaredpv_Maxpv_Minpv_Mul pv_PhaseShiftpv_PhaseShift270pv_PhaseShift90 pv_RandCombId pv_RandCombM pv_RandComb pv_RandWipeId pv_RandWipeM pv_RandWipe pv_RectComb pv_RectComb2pan2pan4panAzpanBpanB2partConvpause pauseSelfpauseSelfWhenDonepeak peakFollower pinkNoiseId pinkNoiseM pinkNoisepitch pitchShiftplayBufpluckpulse pulseCount pulseDividerquadCquadLquadNrhpfrlpfradiansPerSampleramprandIdrandMrandrandIDrandSeed recordBuf replaceOutresonzringzrotate2 runningMax runningMin runningSum sampleDur sampleRatesanitizesawschmidtselectsendTrig setResetFFshapersinOscsinOscFBslew specCentroid specFlatness specPcilespring standardL standardNstepperstereoConvolution2LsubsampleOffsetsum3sum4sweepsyncSawt2at2ktBalltDelaytDuty tExpRandId tExpRandMtExpRandtGrainstiRandIdtiRandMtiRandtRandIdtRandMtRand tWindexIdtWindexMtWindextimertoggleFFtrigtrig1twoPoletwoZerovDiskInvOscvOsc3varLagvarSaw vibratoIdvibratoMvibratowarp1 whiteNoiseId whiteNoiseM whiteNoisewrap wrapIndexxFade2xLinexOut zeroCrossing maxLocalBufsmulAddsetBufc_randc_irandugen_optimise_ir_randugen_optimise_const_operator constant_optmulAddOptimiseddinfceilunitMidiunitCpssum_optuseqId listFillId listFillMlistFillmceConstmceGenIdmceGenMmceSizemceMeanmceFill mceFillId mceFillIntmixmixTomixFill mixFillInt mixFillUgen mixFillIdmixFillMugen_primitive_setprimitive_is_pv_rateugen_is_pv_ratepv_track_bufferbuffer_nframespv_track_nframesugen_remove_out_nodeU_NODE_KS_COUNT U_Node_NoIdU_Graph ug_next_id ug_constants ug_controlsug_ugensU_NodeU_Node_CU_Node_KU_Node_UU_Node_P u_node_idu_node_c_value u_node_k_rateu_node_k_index u_node_k_nameu_node_k_default u_node_k_type u_node_k_meta u_node_u_rate u_node_u_nameu_node_u_inputsu_node_u_outputsu_node_u_specialu_node_u_ugenid u_node_p_idu_node_p_index u_node_p_rateU_EdgeTo_Port to_port_nid to_port_idx From_Port From_Port_C From_Port_K From_Port_U from_port_nid from_port_kt from_port_idx u_node_is_c u_node_is_k u_node_is_uu_node_k_to_controlu_node_user_nameport_idx_or_zerois_from_port_u is_u_node_cis_u_node_c_of is_u_node_kis_u_node_k_of is_u_node_u u_node_k_cmp u_node_sort u_node_k_eq u_node_rate u_node_labelu_node_in_edgesu_node_from_portu_node_sort_controls u_node_ktypeu_node_is_controlu_node_is_implicit_controlu_node_is_implicitu_node_localbuf_countu_node_fetch_ku_node_eq_noidu_node_mk_ktype_mapu_node_ks_countu_node_mk_implicit_ctlu_edge_multiple_out_edgesug_edgesug_empty_graph ug_maximum_id ug_find_nodeug_from_port_nodeug_from_port_node_err ug_push_c ug_mk_node_c ug_push_k ug_mk_node_k ug_push_uug_mk_node_rec ug_mk_node_u ug_mk_node_p ug_mk_nodeug_add_implicit_ctlug_add_implicit_bufug_add_implicitug_remove_implicitu_node_descendentsug_pv_multiple_out_edges ug_pv_checkug_pv_validateugen_to_graph_direct ugen_to_graph ug_stat_lnug_statug_ugen_indices $fShowU_Graph $fEqU_Node $fShowU_Node $fEqTo_Port $fShowTo_Port $fEqFrom_Port$fShowFrom_Portconstant_to_controlc_lift_from_port c_lift_inputs c_lift_ugen c_lift_ugenslift_constantsfrom_port_labelis_operator_nameparenthesise_operatorreconstruct_graphreconstruct_graph_modulereconstruct_graph_strreconstruct_c_strreconstruct_c_ugenreconstruct_k_rndreconstruct_k_strreconstruct_k_ugen ugen_qnamereconstruct_mce_strreconstruct_u_strreconstruct_mrg_strcontrol_to_nodeinput_to_from_port ugen_to_nodegraphdef_to_graph read_graphscsyndef_ug_stat Encoding_MapsInt_Mapmk_encoding_maps uid_lookupktype_map_lookup make_input make_control make_ugengraph_to_graphdeffm7_mxgreyholemiBraids_mode_dictmiBraids_mode_maybe miBraids_modemiClouds_mode_dictmiClouds_mode_maybe miClouds_modemiPlaits_mode_dictmiPlaits_mode_maybe miPlaits_modemiRings_mode_dictmiRings_mode_maybe miRings_modepulseDPWpv_SplitUnpackpv_SplitAllocIdpv_SplitAllocM pv_SplitAllocpv_SplitAllocUnpackId asLocalBufId asLocalBufM asLocalBuf balanceStereo bLowPass4bHiPass4bufRdNbufRdLbufRdCchangedchooseIdchooseMchooseclearLocalBufIdclearLocalBufM clearLocalBufdconsIddconsMdconsdynKlangdynKlankexprange in_exprangefft' fftAllocId fftAllocMfftAllocfirstPrivateBusfreqShift_hilbert gateReset hilbertFIRifft' klanx_spec_f klangSpec klangSpec_k klangSpec_mce klankSpec klankSpec_k klankSpec_mce lchooseIdlchooseMlchooselinExp_blinExp_ulinLinlinLin_ulinLin_blocalIn' makeFadeEnvmouseButtonRand mouseRandId mouseRandM mouseRand mouseXRand mouseYRand onsetType onsetsDefault packFFTSpecpartConv_calcAccumSizepmOscpollExt privateIn privateOut pvcollectpv_calcPVRecSizerand0Idrand0Mrand0rand2Idrand2Mrand2 rotateStereo runningSumRMSselectXsetBuf'silentsoundInsplaytap tChooseIdtChooseMtChoosetLinetXLinetriAS tWChooseId tWChooseMtWChoose unpackFFT varLag_env whiteNoiseMN whiteNoiseNwrapOut playBufCFosc1 ControlSpecCtl16Ctl8 CcEventMetaCcEventcc_event_from_listccEventMetaDefaultccEventMetaControls ccEventAddrccEventVoicerAddr ccEventVoicervoicerccEventVoicerParamccEventGateResetctl8At ctl8Voicer ctl16Voicercontrol_spec_parsecontrol_spec_seq_parsecontrol_spec_printcontrol_spec_seq_printcontrol_spec_to_controlsc3_control_speckyma_event_value_rangesdefault_ugen_graphgabor_grain_ugen_graphsine_grain_ugen_graphdefault_sampler_ugen_graphSynthdef synthdefName synthdefUgensynthdefdefaultSynthdefdefaultSampler synthdefGraph synthdefParamsynthdef_to_graphdefugen_to_graphdef synthdefData synthdefWritesynthdefWrite_dir synthstat_ln synthstat synthstat_wrsynthstat_conciseugen_dump_ugens $fEqSynthdef$fShowSynthdef cmd_check_argb_bufnumb_ixb_chb_sizeb_alloc b_allocReadb_allocReadChannelb_closeb_fillb_freeb_gen b_gen_sine1 b_gen_sine2 b_gen_sine3 b_gen_cheby b_gen_copyb_getb_getnb_queryb_read b_readChannelb_setb_setnb_writeb_zeroc_fillc_getc_getnc_setc_setn d_recv_bytes d_recv_grd_recvd_load d_loadDird_free g_deepFree g_freeAllg_headg_newg_tail g_dumpTree g_queryTreen_idn_aftern_beforen_filln_freen_mapn_mapnn_mapan_mapann_queryn_runn_setn_setnn_tracen_orderp_news_gets_getns_news_noidcmd clearScheddumpOsc errorModenotifynrt_endquitstatussyncwith_completion_packetwithCM b_alloc_setn1b_getn1b_query1b_set1b_setn1b_setn1_segmentedc_getn1c_set1c_setn1n_run1n_set1s_new0 b_segment b_indicespartConv_preparePartConvunpack_n_info_datum_plainunpack_n_info_plain unpack_n_infounpack_n_info_err unpack_tr unpack_tr_err unpack_b_setnunpack_b_setn_err unpack_b_infounpack_b_info_errSynth_IdGroup_IdNode_IdBus_IdBuffer_Leave_File_Open Buffer_Ix readChanToNc sndfileDiskIn sndfileIn sndfileVarIn sndfileRead bGenSine1 bGenSine1Tbl bGenCheby bGenChebyTbl Query_Node Query_Group Query_Synth Query_CtlextractStatusField statusFields statusFormatstatus_format_concise query_ctl_pp query_node_pp queryTree_ctlqueryTree_synthqueryTree_groupqueryTree_child queryTreequeryNode_to_group_seq queryTree_rt$fEqQuery_Node$fShowQuery_Node Nrt_Ugen_Opt nrt_ugen_recnrt_ugen_renderAudibleplay_idplayasync maybe_asyncmaybe_async_atwithSc3stopreset playGraphdef playSynthdefplayUgen run_bundlenrt_play nrt_audition audition_idauditionwithNotifications b_getn1_datab_getn1_data_segmentb_fetchb_fetch1 serverStatusserverSampleRateNominalserverSampleRateActualserverStatusData $fAudibleUgen$fAudibleSynthdef$fAudibleGraphdef nrt_merge nrt_merge_set nrt_emptynrt_insert_prenrt_insert_post nrt_end_time nrt_close nrt_append encode_blob envTrapezoidfirst_zero_then_one env_circle_uenvGate envGate_defplayAtPlay_Opt Sc3_Addressasync_sc3_default_udp sc3_udp_limit withSc3AtwithSc3_ withSc3_tm withSc3AtSeq withSc3AtSeq_play_graphdef_msgrecv_or_load_graphdefnrt_play_reorder auditionAt auditionAtSeq def_play_opt auditionSeq b_fetch_hdrb_query1_unpack_genericb_query1_unpack c_getn1_datan_query1_unpack_fn_query1_unpackn_query1_unpack_plaing_queryTree1_unpackserver_status_concise serverTreeScsynthscsynthResetMessages newScsynth scsynthPrintscsynthOnReset scsynthReset scsynthPlayAt scsynthPlay SC3_Recorder rec_sftype rec_coding rec_fnamerec_ncrec_bus rec_buf_idrec_buf_frames rec_node_id rec_group_idrec_durdefault_SC3_Recorderrec_synthdef_nm rec_synthdef rec_init_m rec_begin_m rec_end_m sc3_recorderbasereadsGHC.EnumEnumGHC.Listtaillookupghc-prim GHC.Classescompare Data.Foldable concatMapSystem.EnvironmentgetEnvgetEnvironment lookupEnvGHC.ErrerrorGHC.Numabs- Data.Tupleuncurry fromIntegerGHC.Realtruncateroundceilingfloordiv Data.Fixedmod'properFraction GHC.Floatsqrtnot GHC.TypesBool==/=<<=>>=GHC.BaseflipNumEq Fractional!!mapsum.lengthTrue GHC.MaybeNothingRealFracIntegral Data.MaybeisJusttoEnumidsinData.TraversablesequencerepeatMonad+Functor Applicative*/transformers-0.5.6.2Control.Monad.Trans.State.LazyStateData.Functor.Identity runIdentity evalStaterunStatefst System.IOputStrLn Data.OldListunlinesbytestring-0.11.3.1Data.ByteString.Lazy.Internal ByteString hosc-0.20-1upVR8Rqz0VLJrvLHi36zfSound.Osc.PacketBundlespan bundleTimeData.ByteString.LazyreadFileFloatDoubleString replicate Data.FunctiononFloatingcontainers-0.6.5.1 Data.TreeTreeMessageSound.Osc.Transport.Fd waitReply Data.Functorvoid sendMessageSound.Osc.Time.Thread.MonadIOpauseThreadUntilSound.Osc.DatumTimeheadSound.Osc.Transport.Monad