packages feed

hsc3 0.15.1 → 0.16

raw patch · 873 files changed

+13697/−9280 lines, 873 filesdep +arraydep +vectordep ~basedep ~hoscPVP ok

version bump matches the API change (PVP)

Dependencies added: array, vector

Dependency ranges changed: base, hosc

API changes (from Hackage documentation)

- Sound.SC3.Common: CI :: Case_Rule
- Sound.SC3.Common: CS :: Case_Rule
- Sound.SC3.Common: data Case_Rule
- Sound.SC3.Common: instance Eq Case_Rule
- Sound.SC3.Common: is_ci :: Case_Rule -> Bool
- Sound.SC3.Common: is_cs :: Case_Rule -> Bool
- Sound.SC3.Common: lookup_by :: (a -> a -> Bool) -> a -> [(a, b)] -> Maybe b
- Sound.SC3.Common: mk_duples :: (a -> c) -> (b -> c) -> [(a, b)] -> [c]
- Sound.SC3.Common: mk_duples_l :: (Int -> c) -> (a -> c) -> (b -> c) -> [(a, [b])] -> [c]
- Sound.SC3.Common: mk_triples :: (a -> d) -> (b -> d) -> (c -> d) -> [(a, b, c)] -> [d]
- Sound.SC3.Common: parse_enum :: (Show t, Enum t, Bounded t) => Case_Rule -> String -> Maybe t
- Sound.SC3.Common: pcn_triples :: [a] -> [(Maybe a, a, Maybe a)]
- Sound.SC3.Common: reads_exact :: Read a => String -> Maybe a
- Sound.SC3.Common: rlookup_by :: (b -> b -> Bool) -> b -> [(a, b)] -> Maybe a
- Sound.SC3.Common: rlookup_str :: Case_Rule -> String -> [(a, String)] -> Maybe a
- Sound.SC3.Common: string_eq :: Case_Rule -> String -> String -> Bool
- Sound.SC3.Common: type T2 a = (a, a)
- Sound.SC3.Common: type T3 a = (a, a, a)
- Sound.SC3.Common: type T4 a = (a, a, a, a)
- Sound.SC3.Common.Monad.Syntax: (*.) :: (Functor f, Num a) => a -> f a -> f a
- Sound.SC3.Common.Monad.Syntax: (+.) :: (Functor f, Num a) => a -> f a -> f a
- Sound.SC3.Common.Monad.Syntax: (-.) :: (Functor f, Num a) => a -> f a -> f a
- Sound.SC3.Common.Monad.Syntax: (.*) :: (Functor f, Num a) => f a -> a -> f a
- Sound.SC3.Common.Monad.Syntax: (.*.) :: (Applicative m, Num a) => m a -> m a -> m a
- Sound.SC3.Common.Monad.Syntax: (.+) :: (Functor f, Num a) => f a -> a -> f a
- Sound.SC3.Common.Monad.Syntax: (.+.) :: (Applicative m, Num a) => m a -> m a -> m a
- Sound.SC3.Common.Monad.Syntax: (.-) :: (Functor f, Num a) => f a -> a -> f a
- Sound.SC3.Common.Monad.Syntax: (.-.) :: (Applicative m, Num a) => m a -> m a -> m a
- Sound.SC3.Common.Monad.Syntax: (./) :: (Functor f, Fractional a) => f a -> a -> f a
- Sound.SC3.Common.Monad.Syntax: (./.) :: (Applicative m, Fractional a) => m a -> m a -> m a
- Sound.SC3.Common.Monad.Syntax: (/.) :: (Functor f, Fractional a) => a -> f a -> f a
- Sound.SC3.Common.Monad.Syntax: chainM :: Monad m => Int -> (b -> m b) -> b -> m b
- Sound.SC3.Common.Monad.Syntax: composeM :: Monad m => [a -> m a] -> a -> m a
- Sound.SC3.Server.Command.Completion: b_alloc' :: OSC o => o -> Int -> Int -> Int -> Message
- Sound.SC3.Server.Command.Completion: b_allocRead' :: OSC o => o -> Int -> String -> Int -> Int -> Message
- Sound.SC3.Server.Command.Completion: b_allocReadChannel' :: OSC o => o -> Int -> String -> Int -> Int -> [Int] -> Message
- Sound.SC3.Server.Command.Completion: b_close' :: OSC o => o -> Int -> Message
- Sound.SC3.Server.Command.Completion: b_free' :: OSC o => o -> Int -> Message
- Sound.SC3.Server.Command.Completion: b_read' :: OSC o => o -> Int -> String -> Int -> Int -> Int -> Bool -> Message
- Sound.SC3.Server.Command.Completion: b_readChannel' :: OSC o => o -> Int -> String -> Int -> Int -> Int -> Bool -> [Int] -> Message
- Sound.SC3.Server.Command.Completion: b_write' :: OSC o => o -> Int -> String -> SoundFileFormat -> SampleFormat -> Int -> Int -> Bool -> Message
- Sound.SC3.Server.Command.Completion: b_zero' :: OSC o => o -> Int -> Message
- Sound.SC3.Server.Command.Completion: d_load' :: OSC o => o -> String -> Message
- Sound.SC3.Server.Command.Completion: d_loadDir' :: OSC o => o -> String -> Message
- Sound.SC3.Server.Command.Completion: d_recv' :: OSC o => o -> Synthdef -> Message
- Sound.SC3.Server.Enum: instance Bounded B_Gen
- Sound.SC3.Server.Enum: instance Enum AddAction
- Sound.SC3.Server.Enum: instance Enum B_Gen
- Sound.SC3.Server.Enum: instance Enum ErrorMode
- Sound.SC3.Server.Enum: instance Enum ErrorScope
- Sound.SC3.Server.Enum: instance Enum PrintLevel
- Sound.SC3.Server.Enum: instance Enum SampleFormat
- Sound.SC3.Server.Enum: instance Enum SoundFileFormat
- Sound.SC3.Server.Enum: instance Eq AddAction
- Sound.SC3.Server.Enum: instance Eq B_Gen
- Sound.SC3.Server.Enum: instance Eq ErrorMode
- Sound.SC3.Server.Enum: instance Eq ErrorScope
- Sound.SC3.Server.Enum: instance Eq PrintLevel
- Sound.SC3.Server.Enum: instance Eq SampleFormat
- Sound.SC3.Server.Enum: instance Eq SoundFileFormat
- Sound.SC3.Server.Enum: instance Read SampleFormat
- Sound.SC3.Server.Enum: instance Read SoundFileFormat
- Sound.SC3.Server.Enum: instance Show AddAction
- Sound.SC3.Server.Enum: instance Show B_Gen
- Sound.SC3.Server.Enum: instance Show ErrorMode
- Sound.SC3.Server.Enum: instance Show ErrorScope
- Sound.SC3.Server.Enum: instance Show PrintLevel
- Sound.SC3.Server.Enum: instance Show SampleFormat
- Sound.SC3.Server.Enum: instance Show SoundFileFormat
- Sound.SC3.Server.Graphdef: graphdef_constants :: Graphdef -> [Sample]
- Sound.SC3.Server.Graphdef: graphdef_controls :: Graphdef -> [(Control, Sample)]
- Sound.SC3.Server.Graphdef: graphdef_name :: Graphdef -> Name
- Sound.SC3.Server.Graphdef: graphdef_ugens :: Graphdef -> [UGen]
- Sound.SC3.Server.Graphdef: instance Eq Graphdef
- Sound.SC3.Server.Graphdef: instance Eq Input
- Sound.SC3.Server.Graphdef: instance Show Graphdef
- Sound.SC3.Server.Graphdef: instance Show Input
- Sound.SC3.Server.NRT: instance Show NRT
- Sound.SC3.Server.NRT: nrt_bundles :: NRT -> [Bundle]
- Sound.SC3.Server.Recorder: instance Default SC3_Recorder
- Sound.SC3.Server.Recorder: rec_buf_frames :: SC3_Recorder -> Int
- Sound.SC3.Server.Recorder: rec_buf_id :: SC3_Recorder -> Int
- Sound.SC3.Server.Recorder: rec_bus :: SC3_Recorder -> Int
- Sound.SC3.Server.Recorder: rec_coding :: SC3_Recorder -> SampleFormat
- Sound.SC3.Server.Recorder: rec_dur :: SC3_Recorder -> Maybe Time
- Sound.SC3.Server.Recorder: rec_fname :: SC3_Recorder -> FilePath
- Sound.SC3.Server.Recorder: rec_group_id :: SC3_Recorder -> Int
- Sound.SC3.Server.Recorder: rec_nc :: SC3_Recorder -> Int
- Sound.SC3.Server.Recorder: rec_node_id :: SC3_Recorder -> Int
- Sound.SC3.Server.Recorder: rec_sftype :: SC3_Recorder -> SoundFileFormat
- Sound.SC3.Server.Status: instance Eq Query_Node
- Sound.SC3.Server.Status: instance Show Query_Node
- Sound.SC3.Server.Synthdef: instance Default Synthdef
- Sound.SC3.Server.Synthdef: instance Eq Synthdef
- Sound.SC3.Server.Synthdef: instance Show Synthdef
- Sound.SC3.Server.Synthdef: synthdefName :: Synthdef -> String
- Sound.SC3.Server.Synthdef: synthdefUGen :: Synthdef -> UGen
- Sound.SC3.Server.Transport.FD: instance Audible Graphdef
- Sound.SC3.Server.Transport.FD: instance Audible NRT
- Sound.SC3.Server.Transport.FD: instance Audible Synthdef
- Sound.SC3.Server.Transport.FD: instance Audible UGen
- Sound.SC3.Server.Transport.FD: performNRT :: Transport t => t -> NRT -> IO ()
- Sound.SC3.Server.Transport.FD: send :: Transport t => t -> Message -> IO ()
- Sound.SC3.Server.Transport.Monad: instance Audible Graphdef
- Sound.SC3.Server.Transport.Monad: instance Audible NRT
- Sound.SC3.Server.Transport.Monad: instance Audible Synthdef
- Sound.SC3.Server.Transport.Monad: instance Audible UGen
- Sound.SC3.Server.Transport.Monad: performNRT :: Transport m => NRT -> m ()
- Sound.SC3.Server.Transport.Monad: send :: SendOSC m => Message -> m ()
- Sound.SC3.UGen.Bindings.DB: fBSineC :: Rate -> UGen -> UGen -> UGen -> UGen -> UGen -> UGen -> UGen -> UGen
- Sound.SC3.UGen.Bindings.DB: fBSineL :: Rate -> UGen -> UGen -> UGen -> UGen -> UGen -> UGen -> UGen -> UGen
- Sound.SC3.UGen.Bindings.DB: fBSineN :: Rate -> UGen -> UGen -> UGen -> UGen -> UGen -> UGen -> UGen -> UGen
- Sound.SC3.UGen.Bindings.HW.External.ATS: ATS :: ATSHeader -> [Double] -> ATS
- Sound.SC3.UGen.Bindings.HW.External.ATS: ATSHeader :: Double -> Int -> Int -> Int -> Int -> Double -> Double -> Double -> Int -> Int -> ATSHeader
- Sound.SC3.UGen.Bindings.HW.External.ATS: atsAnalysisDuration :: ATSHeader -> Double
- Sound.SC3.UGen.Bindings.HW.External.ATS: atsData :: ATS -> [Double]
- Sound.SC3.UGen.Bindings.HW.External.ATS: atsFileType :: ATSHeader -> Int
- Sound.SC3.UGen.Bindings.HW.External.ATS: atsFrameLength :: ATSHeader -> Int
- Sound.SC3.UGen.Bindings.HW.External.ATS: atsFrameSize :: ATSHeader -> Int
- Sound.SC3.UGen.Bindings.HW.External.ATS: atsFrames :: ATS -> [ATSFrame]
- Sound.SC3.UGen.Bindings.HW.External.ATS: atsHeader :: ATS -> ATSHeader
- Sound.SC3.UGen.Bindings.HW.External.ATS: atsMaxAmplitude :: ATSHeader -> Double
- Sound.SC3.UGen.Bindings.HW.External.ATS: atsMaxFrequency :: ATSHeader -> Double
- Sound.SC3.UGen.Bindings.HW.External.ATS: atsNFrames :: ATSHeader -> Int
- Sound.SC3.UGen.Bindings.HW.External.ATS: atsNPartials :: ATSHeader -> Int
- Sound.SC3.UGen.Bindings.HW.External.ATS: atsRead :: FilePath -> IO ATS
- Sound.SC3.UGen.Bindings.HW.External.ATS: atsSampleRate :: ATSHeader -> Double
- Sound.SC3.UGen.Bindings.HW.External.ATS: atsWindowSize :: ATSHeader -> Int
- Sound.SC3.UGen.Bindings.HW.External.ATS: data ATS
- Sound.SC3.UGen.Bindings.HW.External.ATS: data ATSHeader
- Sound.SC3.UGen.Bindings.HW.External.ATS: instance Eq ATS
- Sound.SC3.UGen.Bindings.HW.External.ATS: instance Eq ATSHeader
- Sound.SC3.UGen.Bindings.HW.External.ATS: instance Show ATS
- Sound.SC3.UGen.Bindings.HW.External.ATS: instance Show ATSHeader
- Sound.SC3.UGen.Bindings.HW.External.ATS: type ATSFrame = [Double]
- Sound.SC3.UGen.Bindings.HW.External.ID: lfBrownNoise0 :: ID a => a -> Rate -> UGen -> UGen -> UGen -> UGen
- Sound.SC3.UGen.Bindings.HW.External.ID: lfBrownNoise1 :: ID a => a -> Rate -> UGen -> UGen -> UGen -> UGen
- Sound.SC3.UGen.Bindings.HW.External.ID: lfBrownNoise2 :: ID a => a -> Rate -> UGen -> UGen -> UGen -> UGen
- Sound.SC3.UGen.Bindings.HW.External.LPC: LPC :: LPCHeader -> [LPCFrame] -> LPC
- Sound.SC3.UGen.Bindings.HW.External.LPC: LPCHeader :: Int -> Int -> Int -> Int -> Float -> Float -> Float -> Int -> LPCHeader
- Sound.SC3.UGen.Bindings.HW.External.LPC: data LPC
- Sound.SC3.UGen.Bindings.HW.External.LPC: data LPCHeader
- Sound.SC3.UGen.Bindings.HW.External.LPC: instance Eq LPC
- Sound.SC3.UGen.Bindings.HW.External.LPC: instance Eq LPCHeader
- Sound.SC3.UGen.Bindings.HW.External.LPC: instance Show LPC
- Sound.SC3.UGen.Bindings.HW.External.LPC: instance Show LPCHeader
- Sound.SC3.UGen.Bindings.HW.External.LPC: lpcAnalysisDuration :: LPCHeader -> Float
- Sound.SC3.UGen.Bindings.HW.External.LPC: lpcFrameRate :: LPCHeader -> Float
- Sound.SC3.UGen.Bindings.HW.External.LPC: lpcFrameSize :: LPCHeader -> Int
- Sound.SC3.UGen.Bindings.HW.External.LPC: lpcFrames :: LPC -> [LPCFrame]
- Sound.SC3.UGen.Bindings.HW.External.LPC: lpcHeader :: LPC -> LPCHeader
- Sound.SC3.UGen.Bindings.HW.External.LPC: lpcHeaderSize :: LPCHeader -> Int
- Sound.SC3.UGen.Bindings.HW.External.LPC: lpcMagic :: LPCHeader -> Int
- Sound.SC3.UGen.Bindings.HW.External.LPC: lpcNFrames :: LPCHeader -> Int
- Sound.SC3.UGen.Bindings.HW.External.LPC: lpcNPoles :: LPCHeader -> Int
- Sound.SC3.UGen.Bindings.HW.External.LPC: lpcRead :: FilePath -> IO LPC
- Sound.SC3.UGen.Bindings.HW.External.LPC: lpcSC3 :: LPC -> [Float]
- Sound.SC3.UGen.Bindings.HW.External.LPC: lpcSampleRate :: LPCHeader -> Float
- Sound.SC3.UGen.Bindings.HW.External.LPC: type LPCFrame = [Float]
- Sound.SC3.UGen.Bindings.HW.External.Zita: zr1_delay :: ZitaRev1 a -> a
- Sound.SC3.UGen.Bindings.HW.External.Zita: zr1_eq1fr :: ZitaRev1 a -> a
- Sound.SC3.UGen.Bindings.HW.External.Zita: zr1_eq1gn :: ZitaRev1 a -> a
- Sound.SC3.UGen.Bindings.HW.External.Zita: zr1_eq2fr :: ZitaRev1 a -> a
- Sound.SC3.UGen.Bindings.HW.External.Zita: zr1_eq2gn :: ZitaRev1 a -> a
- Sound.SC3.UGen.Bindings.HW.External.Zita: zr1_fdamp :: ZitaRev1 a -> a
- Sound.SC3.UGen.Bindings.HW.External.Zita: zr1_in1 :: ZitaRev1 a -> a
- Sound.SC3.UGen.Bindings.HW.External.Zita: zr1_in2 :: ZitaRev1 a -> a
- Sound.SC3.UGen.Bindings.HW.External.Zita: zr1_level :: ZitaRev1 a -> a
- Sound.SC3.UGen.Bindings.HW.External.Zita: zr1_opmix :: ZitaRev1 a -> a
- Sound.SC3.UGen.Bindings.HW.External.Zita: zr1_rtlow :: ZitaRev1 a -> a
- Sound.SC3.UGen.Bindings.HW.External.Zita: zr1_rtmid :: ZitaRev1 a -> a
- Sound.SC3.UGen.Bindings.HW.External.Zita: zr1_xover :: ZitaRev1 a -> a
- Sound.SC3.UGen.Enum: EnvCub :: Envelope_Curve a
- Sound.SC3.UGen.Enum: EnvExp :: Envelope_Curve a
- Sound.SC3.UGen.Enum: EnvHold :: Envelope_Curve a
- Sound.SC3.UGen.Enum: EnvLin :: Envelope_Curve a
- Sound.SC3.UGen.Enum: EnvNum :: a -> Envelope_Curve a
- Sound.SC3.UGen.Enum: EnvSin :: Envelope_Curve a
- Sound.SC3.UGen.Enum: EnvSqr :: Envelope_Curve a
- Sound.SC3.UGen.Enum: EnvStep :: Envelope_Curve a
- Sound.SC3.UGen.Enum: EnvWelch :: Envelope_Curve a
- Sound.SC3.UGen.Enum: data Envelope_Curve a
- Sound.SC3.UGen.Enum: data Loop
- Sound.SC3.UGen.Enum: env_curve_interpolation_f :: (Ord t, Floating t) => Envelope_Curve t -> Interpolation_F t
- Sound.SC3.UGen.Enum: env_curve_shape :: Num a => Envelope_Curve a -> a
- Sound.SC3.UGen.Enum: env_curve_value :: Num a => Envelope_Curve a -> a
- Sound.SC3.UGen.Enum: instance Eq Buffer
- Sound.SC3.UGen.Enum: instance Eq DoneAction
- Sound.SC3.UGen.Enum: instance Eq Interpolation
- Sound.SC3.UGen.Enum: instance Eq Loop
- Sound.SC3.UGen.Enum: instance Eq Warp
- Sound.SC3.UGen.Enum: instance Eq a => Eq (Envelope_Curve a)
- Sound.SC3.UGen.Enum: instance Show Buffer
- Sound.SC3.UGen.Enum: instance Show DoneAction
- Sound.SC3.UGen.Enum: instance Show Interpolation
- Sound.SC3.UGen.Enum: instance Show Loop
- Sound.SC3.UGen.Enum: instance Show Warp
- Sound.SC3.UGen.Enum: instance Show a => Show (Envelope_Curve a)
- Sound.SC3.UGen.Enum: type Envelope_Curve2 a = T2 (Envelope_Curve a)
- Sound.SC3.UGen.Enum: type Envelope_Curve3 a = T3 (Envelope_Curve a)
- Sound.SC3.UGen.Enum: type Envelope_Curve4 a = T4 (Envelope_Curve a)
- Sound.SC3.UGen.Envelope: Envelope :: [a] -> [a] -> [Envelope_Curve a] -> Maybe Int -> Maybe Int -> Envelope a
- Sound.SC3.UGen.Envelope: d_dx :: Num a => [a] -> [a]
- Sound.SC3.UGen.Envelope: d_dx' :: Num n => [n] -> [n]
- Sound.SC3.UGen.Envelope: data Envelope a
- Sound.SC3.UGen.Envelope: dx_d :: Num n => [n] -> [n]
- Sound.SC3.UGen.Envelope: dx_d' :: Num n => [n] -> [n]
- Sound.SC3.UGen.Envelope: env_circle :: (Num a, Fractional a) => Envelope a -> a -> Envelope_Curve a -> Envelope a
- Sound.SC3.UGen.Envelope: env_curves :: Envelope a -> [Envelope_Curve a]
- Sound.SC3.UGen.Envelope: env_delay :: Envelope a -> a -> Envelope a
- Sound.SC3.UGen.Envelope: env_is_sustained :: Envelope a -> Bool
- Sound.SC3.UGen.Envelope: env_levels :: Envelope a -> [a]
- Sound.SC3.UGen.Envelope: env_loop_node :: Envelope a -> Maybe Int
- Sound.SC3.UGen.Envelope: env_release_node :: Envelope a -> Maybe Int
- Sound.SC3.UGen.Envelope: env_times :: Envelope a -> [a]
- Sound.SC3.UGen.Envelope: envelope :: [a] -> [a] -> [Envelope_Curve a] -> Envelope a
- Sound.SC3.UGen.Envelope: envelope_at :: (Ord t, Floating t) => Envelope t -> t -> t
- Sound.SC3.UGen.Envelope: envelope_curves :: Num a => Envelope a -> [Envelope_Curve a]
- Sound.SC3.UGen.Envelope: envelope_duration :: Num n => Envelope n -> n
- Sound.SC3.UGen.Envelope: envelope_is_normal :: (Eq n, Num n) => Envelope n -> Bool
- Sound.SC3.UGen.Envelope: envelope_n_segments :: (Num n, Integral i) => Envelope n -> i
- Sound.SC3.UGen.Envelope: envelope_normalise :: (Num a, Ord a) => Envelope a -> Envelope a
- Sound.SC3.UGen.Envelope: envelope_render :: (Ord t, Floating t, Enum t) => t -> Envelope t -> [(t, t)]
- Sound.SC3.UGen.Envelope: envelope_sc3_array :: Num a => Envelope a -> Maybe [a]
- Sound.SC3.UGen.Envelope: envelope_sc3_ienvgen_array :: Num a => Envelope a -> Maybe [a]
- Sound.SC3.UGen.Envelope: envelope_segment :: Num t => Envelope t -> Int -> Envelope_Segment t
- Sound.SC3.UGen.Envelope: envelope_segment_ix :: (Ord a, Num a) => Envelope a -> a -> Maybe Int
- Sound.SC3.UGen.Envelope: envelope_segments :: Num t => Envelope t -> [Envelope_Segment t]
- Sound.SC3.UGen.Envelope: envelope_table :: (Ord t, Floating t, Enum t) => t -> Envelope t -> [t]
- Sound.SC3.UGen.Envelope: envelope_to_ugen :: Envelope UGen -> UGen
- Sound.SC3.UGen.Envelope: instance Eq a => Eq (Envelope a)
- Sound.SC3.UGen.Envelope: instance Show a => Show (Envelope a)
- Sound.SC3.UGen.Envelope: pack_envelope_segments :: Num t => [Envelope_Segment t] -> ([t], [t], [Envelope_Curve t])
- Sound.SC3.UGen.Envelope: type Envelope_Segment t = (t, t, t, t, Envelope_Curve t)
- Sound.SC3.UGen.Envelope.Construct: ADSR :: a -> a -> a -> a -> a -> Envelope_Curve3 a -> a -> ADSR a
- Sound.SC3.UGen.Envelope.Construct: ADSSR :: a -> a -> a -> a -> a -> a -> a -> Envelope_Curve4 a -> a -> ADSSR a
- Sound.SC3.UGen.Envelope.Construct: ASR :: a -> a -> a -> Envelope_Curve2 a -> ASR a
- Sound.SC3.UGen.Envelope.Construct: LINEN :: a -> a -> a -> a -> Envelope_Curve3 a -> LINEN a
- Sound.SC3.UGen.Envelope.Construct: adsrDefault :: Fractional n => ADSR n
- Sound.SC3.UGen.Envelope.Construct: adsr_attackTime :: ADSR a -> a
- Sound.SC3.UGen.Envelope.Construct: adsr_bias :: ADSR a -> a
- Sound.SC3.UGen.Envelope.Construct: adsr_curve :: ADSR a -> Envelope_Curve3 a
- Sound.SC3.UGen.Envelope.Construct: adsr_decayTime :: ADSR a -> a
- Sound.SC3.UGen.Envelope.Construct: adsr_peakLevel :: ADSR a -> a
- Sound.SC3.UGen.Envelope.Construct: adsr_releaseTime :: ADSR a -> a
- Sound.SC3.UGen.Envelope.Construct: adsr_sustainLevel :: ADSR a -> a
- Sound.SC3.UGen.Envelope.Construct: adssr_attackLevel :: ADSSR a -> a
- Sound.SC3.UGen.Envelope.Construct: adssr_attackTime :: ADSSR a -> a
- Sound.SC3.UGen.Envelope.Construct: adssr_bias :: ADSSR a -> a
- Sound.SC3.UGen.Envelope.Construct: adssr_curve :: ADSSR a -> Envelope_Curve4 a
- Sound.SC3.UGen.Envelope.Construct: adssr_decayLevel :: ADSSR a -> a
- Sound.SC3.UGen.Envelope.Construct: adssr_decayTime :: ADSSR a -> a
- Sound.SC3.UGen.Envelope.Construct: adssr_releaseTime :: ADSSR a -> a
- Sound.SC3.UGen.Envelope.Construct: adssr_slopeTime :: ADSSR a -> a
- Sound.SC3.UGen.Envelope.Construct: adssr_sustainLevel :: ADSSR a -> a
- Sound.SC3.UGen.Envelope.Construct: asr_attackTime :: ASR a -> a
- Sound.SC3.UGen.Envelope.Construct: asr_curve :: ASR a -> Envelope_Curve2 a
- Sound.SC3.UGen.Envelope.Construct: asr_releaseTime :: ASR a -> a
- Sound.SC3.UGen.Envelope.Construct: asr_sustainLevel :: ASR a -> a
- Sound.SC3.UGen.Envelope.Construct: data ADSR a
- Sound.SC3.UGen.Envelope.Construct: data ADSSR a
- Sound.SC3.UGen.Envelope.Construct: data ASR a
- Sound.SC3.UGen.Envelope.Construct: data LINEN a
- Sound.SC3.UGen.Envelope.Construct: envADSR :: Num a => a -> a -> a -> a -> a -> Envelope_Curve a -> a -> Envelope a
- Sound.SC3.UGen.Envelope.Construct: envADSR_r :: Num a => ADSR a -> Envelope a
- Sound.SC3.UGen.Envelope.Construct: envADSSR :: Num a => a -> a -> a -> a -> a -> a -> a -> Envelope_Curve a -> a -> Envelope a
- Sound.SC3.UGen.Envelope.Construct: envADSSR_r :: Num a => ADSSR a -> Envelope a
- Sound.SC3.UGen.Envelope.Construct: envASR :: Num a => a -> a -> a -> Envelope_Curve a -> Envelope a
- Sound.SC3.UGen.Envelope.Construct: envASR_r :: Num a => ASR a -> Envelope a
- Sound.SC3.UGen.Envelope.Construct: envCoord :: Num a => [(a, a)] -> a -> a -> Envelope_Curve a -> Envelope a
- Sound.SC3.UGen.Envelope.Construct: envGate :: UGen -> UGen -> UGen -> DoneAction -> Envelope_Curve UGen -> UGen
- Sound.SC3.UGen.Envelope.Construct: envGate' :: UGen
- Sound.SC3.UGen.Envelope.Construct: envLinen :: Num a => a -> a -> a -> a -> Envelope a
- Sound.SC3.UGen.Envelope.Construct: envLinen' :: Num a => a -> a -> a -> a -> Envelope_Curve3 a -> Envelope a
- Sound.SC3.UGen.Envelope.Construct: envLinen_r :: Num a => LINEN a -> Envelope a
- Sound.SC3.UGen.Envelope.Construct: envPerc :: Num a => a -> a -> Envelope a
- Sound.SC3.UGen.Envelope.Construct: envPerc' :: Num a => a -> a -> a -> Envelope_Curve2 a -> Envelope a
- Sound.SC3.UGen.Envelope.Construct: envSine :: (Num a, Fractional a) => a -> a -> Envelope a
- Sound.SC3.UGen.Envelope.Construct: envStep :: [a] -> [a] -> Maybe Int -> Maybe Int -> Envelope a
- Sound.SC3.UGen.Envelope.Construct: envTrapezoid :: (Num a, OrdE a) => a -> a -> a -> a -> Envelope a
- Sound.SC3.UGen.Envelope.Construct: envTriangle :: (Num a, Fractional a) => a -> a -> Envelope a
- Sound.SC3.UGen.Envelope.Construct: linen_attackTime :: LINEN a -> a
- Sound.SC3.UGen.Envelope.Construct: linen_curve :: LINEN a -> Envelope_Curve3 a
- Sound.SC3.UGen.Envelope.Construct: linen_level :: LINEN a -> a
- Sound.SC3.UGen.Envelope.Construct: linen_releaseTime :: LINEN a -> a
- Sound.SC3.UGen.Envelope.Construct: linen_sustainTime :: LINEN a -> a
- Sound.SC3.UGen.Envelope.Interpolate: cubed :: Floating t => Interpolation_F t
- Sound.SC3.UGen.Envelope.Interpolate: curve :: (Ord t, Floating t) => t -> Interpolation_F t
- Sound.SC3.UGen.Envelope.Interpolate: exponential :: Floating t => Interpolation_F t
- Sound.SC3.UGen.Envelope.Interpolate: exponential' :: (Eq t, Floating t) => Interpolation_F t
- Sound.SC3.UGen.Envelope.Interpolate: exponential'' :: (Eq t, Floating t) => Interpolation_F t
- Sound.SC3.UGen.Envelope.Interpolate: half_pi :: Floating a => a
- Sound.SC3.UGen.Envelope.Interpolate: hold :: (Num t, Eq t) => Interpolation_F t
- Sound.SC3.UGen.Envelope.Interpolate: linear :: Num t => Interpolation_F t
- Sound.SC3.UGen.Envelope.Interpolate: sine :: Floating t => Interpolation_F t
- Sound.SC3.UGen.Envelope.Interpolate: squared :: Floating t => Interpolation_F t
- Sound.SC3.UGen.Envelope.Interpolate: step :: Interpolation_F t
- Sound.SC3.UGen.Envelope.Interpolate: type Interpolation_F t = t -> t -> t -> t
- Sound.SC3.UGen.Envelope.Interpolate: welch :: (Ord t, Floating t) => Interpolation_F t
- Sound.SC3.UGen.Graph: constants :: Graph -> [Node]
- Sound.SC3.UGen.Graph: controls :: Graph -> [Node]
- Sound.SC3.UGen.Graph: instance Eq FromPort
- Sound.SC3.UGen.Graph: instance Eq KType
- Sound.SC3.UGen.Graph: instance Eq ToPort
- Sound.SC3.UGen.Graph: instance Ord KType
- Sound.SC3.UGen.Graph: instance Show FromPort
- Sound.SC3.UGen.Graph: instance Show Graph
- Sound.SC3.UGen.Graph: instance Show KType
- Sound.SC3.UGen.Graph: instance Show Node
- Sound.SC3.UGen.Graph: instance Show ToPort
- Sound.SC3.UGen.Graph: nextId :: Graph -> NodeId
- Sound.SC3.UGen.Graph: node_c_value :: Node -> Sample
- Sound.SC3.UGen.Graph: node_id :: Node -> NodeId
- Sound.SC3.UGen.Graph: node_k_default :: Node -> Sample
- Sound.SC3.UGen.Graph: node_k_index :: Node -> Maybe Int
- Sound.SC3.UGen.Graph: node_k_meta :: Node -> Maybe (C_Meta Sample)
- Sound.SC3.UGen.Graph: node_k_name :: Node -> String
- Sound.SC3.UGen.Graph: node_k_rate :: Node -> Rate
- Sound.SC3.UGen.Graph: node_k_type :: Node -> KType
- Sound.SC3.UGen.Graph: node_p_index :: Node -> PortIndex
- Sound.SC3.UGen.Graph: node_p_node :: Node -> Node
- Sound.SC3.UGen.Graph: node_u_inputs :: Node -> [FromPort]
- Sound.SC3.UGen.Graph: node_u_name :: Node -> String
- Sound.SC3.UGen.Graph: node_u_outputs :: Node -> [Output]
- Sound.SC3.UGen.Graph: node_u_rate :: Node -> Rate
- Sound.SC3.UGen.Graph: node_u_special :: Node -> Special
- Sound.SC3.UGen.Graph: node_u_ugenid :: Node -> UGenId
- Sound.SC3.UGen.Graph: port_idx :: FromPort -> Maybe PortIndex
- Sound.SC3.UGen.Graph: port_kt :: FromPort -> KType
- Sound.SC3.UGen.Graph: port_nid :: FromPort -> NodeId
- Sound.SC3.UGen.Graph: ugens :: Graph -> [Node]
- Sound.SC3.UGen.Identifier: instance ID Char
- Sound.SC3.UGen.Identifier: instance ID Double
- Sound.SC3.UGen.Identifier: instance ID Float
- Sound.SC3.UGen.Identifier: instance ID Int
- Sound.SC3.UGen.Identifier: instance ID Integer
- Sound.SC3.UGen.MCE: instance Eq n => Eq (MCE n)
- Sound.SC3.UGen.MCE: instance Fractional n => Fractional (MCE n)
- Sound.SC3.UGen.MCE: instance Num n => Num (MCE n)
- Sound.SC3.UGen.MCE: instance Show n => Show (MCE n)
- Sound.SC3.UGen.Math: ampDb' :: Floating a => a -> a
- Sound.SC3.UGen.Math: class Num a => TernaryOp a where mul_add i m a = i * m + a
- Sound.SC3.UGen.Math: clip' :: Ord a => a -> a -> a -> a
- Sound.SC3.UGen.Math: clip_ :: Ord a => a -> a -> a -> a
- Sound.SC3.UGen.Math: cpsMIDI' :: Floating a => a -> a
- Sound.SC3.UGen.Math: cpsOct' :: Floating a => a -> a
- Sound.SC3.UGen.Math: cubed' :: Num a => a -> a
- Sound.SC3.UGen.Math: dbAmp' :: Floating a => a -> a
- Sound.SC3.UGen.Math: difSqr' :: Num a => a -> a -> a
- Sound.SC3.UGen.Math: fmod_f32 :: Float -> Float -> Float
- Sound.SC3.UGen.Math: foldToRange :: (Ord a, Num a) => a -> a -> a -> a
- Sound.SC3.UGen.Math: fold_ :: (Ord a, Num a) => a -> a -> a -> a
- Sound.SC3.UGen.Math: genericWrap :: (Ord a, Num a) => a -> a -> a -> a
- Sound.SC3.UGen.Math: hypot_ :: Floating a => a -> a -> a
- Sound.SC3.UGen.Math: hypotx' :: (Ord a, Floating a) => a -> a -> a
- Sound.SC3.UGen.Math: instance BinaryOp Double
- Sound.SC3.UGen.Math: instance BinaryOp Float
- Sound.SC3.UGen.Math: instance BinaryOp UGen
- Sound.SC3.UGen.Math: instance EqE Double
- Sound.SC3.UGen.Math: instance EqE Float
- Sound.SC3.UGen.Math: instance EqE Int
- Sound.SC3.UGen.Math: instance EqE Int32
- Sound.SC3.UGen.Math: instance EqE Int64
- Sound.SC3.UGen.Math: instance EqE Integer
- Sound.SC3.UGen.Math: instance EqE UGen
- Sound.SC3.UGen.Math: instance OrdE Double
- Sound.SC3.UGen.Math: instance OrdE Float
- Sound.SC3.UGen.Math: instance OrdE Int
- Sound.SC3.UGen.Math: instance OrdE Int32
- Sound.SC3.UGen.Math: instance OrdE Int64
- Sound.SC3.UGen.Math: instance OrdE Integer
- Sound.SC3.UGen.Math: instance OrdE UGen
- Sound.SC3.UGen.Math: instance RealFracE Double
- Sound.SC3.UGen.Math: instance RealFracE Float
- Sound.SC3.UGen.Math: instance RealFracE UGen
- Sound.SC3.UGen.Math: instance TernaryOp Double
- Sound.SC3.UGen.Math: instance TernaryOp Float
- Sound.SC3.UGen.Math: instance TernaryOp UGen
- Sound.SC3.UGen.Math: instance UnaryOp Double
- Sound.SC3.UGen.Math: instance UnaryOp Float
- Sound.SC3.UGen.Math: instance UnaryOp UGen
- Sound.SC3.UGen.Math: linLin_muladd :: Fractional t => t -> t -> t -> t -> (t, t)
- Sound.SC3.UGen.Math: linlin :: (Fractional a, TernaryOp a) => a -> a -> a -> a -> a -> a
- Sound.SC3.UGen.Math: linlin' :: Fractional a => a -> a -> a -> a -> a -> a
- Sound.SC3.UGen.Math: midiCPS' :: Floating a => a -> a
- Sound.SC3.UGen.Math: midiRatio' :: Floating a => a -> a
- Sound.SC3.UGen.Math: octCPS' :: Floating a => a -> a
- Sound.SC3.UGen.Math: range :: (Fractional a, TernaryOp a) => a -> a -> a -> a
- Sound.SC3.UGen.Math: range' :: Fractional a => a -> a -> a -> a
- Sound.SC3.UGen.Math: range_muladd :: Fractional t => t -> t -> (t, t)
- Sound.SC3.UGen.Math: ratioMIDI' :: Floating a => a -> a
- Sound.SC3.UGen.Math: roundTo_ :: (RealFrac n, Ord n) => n -> n -> n
- Sound.SC3.UGen.Math: sc3_ceiling :: (RealFrac a, Num a) => a -> a
- Sound.SC3.UGen.Math: sc3_floor :: (RealFrac a, Num a) => a -> a
- Sound.SC3.UGen.Math: sc3_idiv :: RealFrac n => n -> n -> n
- Sound.SC3.UGen.Math: sc3_properFraction :: (RealFrac t, Num t) => t -> (t, t)
- Sound.SC3.UGen.Math: sc3_round :: (RealFrac a, Num a) => a -> a
- Sound.SC3.UGen.Math: sc3_round_to :: (RealFrac n, Ord n) => n -> n -> n
- Sound.SC3.UGen.Math: sc3_truncate :: (RealFrac a, Num a) => a -> a
- Sound.SC3.UGen.Math: squared' :: Num a => a -> a
- Sound.SC3.UGen.Math: urange :: (Fractional a, TernaryOp a) => a -> a -> a -> a
- Sound.SC3.UGen.Math: urange' :: Fractional a => a -> a -> a -> a
- Sound.SC3.UGen.Math: wrap' :: RealFracE n => n -> n -> n -> n
- Sound.SC3.UGen.Math: wrap_ :: RealFracE n => n -> n -> n -> n
- Sound.SC3.UGen.Operator: instance Bounded Binary
- Sound.SC3.UGen.Operator: instance Bounded Unary
- Sound.SC3.UGen.Operator: instance Enum Binary
- Sound.SC3.UGen.Operator: instance Enum Unary
- Sound.SC3.UGen.Operator: instance Eq Binary
- Sound.SC3.UGen.Operator: instance Eq Unary
- Sound.SC3.UGen.Operator: instance Read Binary
- Sound.SC3.UGen.Operator: instance Read Unary
- Sound.SC3.UGen.Operator: instance Show Binary
- Sound.SC3.UGen.Operator: instance Show Unary
- Sound.SC3.UGen.Rate: instance Bounded Rate
- Sound.SC3.UGen.Rate: instance Enum Rate
- Sound.SC3.UGen.Rate: instance Eq Rate
- Sound.SC3.UGen.Rate: instance Ord Rate
- Sound.SC3.UGen.Rate: instance Read Rate
- Sound.SC3.UGen.Rate: instance Show Rate
- Sound.SC3.UGen.Type: c_meta' :: (n -> m) -> C_Meta' n -> C_Meta m
- Sound.SC3.UGen.Type: constantValue :: Constant -> Sample
- Sound.SC3.UGen.Type: controlDefault :: Control -> Sample
- Sound.SC3.UGen.Type: controlIndex :: Control -> Maybe Int
- Sound.SC3.UGen.Type: controlMeta :: Control -> Maybe (C_Meta Sample)
- Sound.SC3.UGen.Type: controlName :: Control -> String
- Sound.SC3.UGen.Type: controlOperatingRate :: Control -> Rate
- Sound.SC3.UGen.Type: controlTriggered :: Control -> Bool
- Sound.SC3.UGen.Type: ctl_max :: C_Meta n -> n
- Sound.SC3.UGen.Type: ctl_min :: C_Meta n -> n
- Sound.SC3.UGen.Type: ctl_step :: C_Meta n -> n
- Sound.SC3.UGen.Type: ctl_units :: C_Meta n -> String
- Sound.SC3.UGen.Type: ctl_warp :: C_Meta n -> String
- Sound.SC3.UGen.Type: instance Bits UGen
- Sound.SC3.UGen.Type: instance Enum UGen
- Sound.SC3.UGen.Type: instance Eq Constant
- Sound.SC3.UGen.Type: instance Eq Control
- Sound.SC3.UGen.Type: instance Eq Label
- Sound.SC3.UGen.Type: instance Eq MRG
- Sound.SC3.UGen.Type: instance Eq Primitive
- Sound.SC3.UGen.Type: instance Eq Proxy
- Sound.SC3.UGen.Type: instance Eq Special
- Sound.SC3.UGen.Type: instance Eq UGen
- Sound.SC3.UGen.Type: instance Eq UGenId
- Sound.SC3.UGen.Type: instance Eq n => Eq (C_Meta n)
- Sound.SC3.UGen.Type: instance Floating UGen
- Sound.SC3.UGen.Type: instance Fractional UGen
- Sound.SC3.UGen.Type: instance Integral UGen
- Sound.SC3.UGen.Type: instance Num UGen
- Sound.SC3.UGen.Type: instance Ord Constant
- Sound.SC3.UGen.Type: instance Ord UGen
- Sound.SC3.UGen.Type: instance Random UGen
- Sound.SC3.UGen.Type: instance Real UGen
- Sound.SC3.UGen.Type: instance RealFrac UGen
- Sound.SC3.UGen.Type: instance Show Constant
- Sound.SC3.UGen.Type: instance Show Control
- Sound.SC3.UGen.Type: instance Show Label
- Sound.SC3.UGen.Type: instance Show MRG
- Sound.SC3.UGen.Type: instance Show Primitive
- Sound.SC3.UGen.Type: instance Show Proxy
- Sound.SC3.UGen.Type: instance Show Special
- Sound.SC3.UGen.Type: instance Show UGen
- Sound.SC3.UGen.Type: instance Show UGenId
- Sound.SC3.UGen.Type: instance Show n => Show (C_Meta n)
- Sound.SC3.UGen.Type: mrgLeft :: MRG -> UGen
- Sound.SC3.UGen.Type: mrgRight :: MRG -> UGen
- Sound.SC3.UGen.Type: proxyIndex :: Proxy -> Int
- Sound.SC3.UGen.Type: proxySource :: Proxy -> Primitive
- Sound.SC3.UGen.Type: type C_Meta' n = (n, n, String, n, String)
- Sound.SC3.UGen.Type: ugenId :: Primitive -> UGenId
- Sound.SC3.UGen.Type: ugenInputs :: Primitive -> [UGen]
- Sound.SC3.UGen.Type: ugenLabel :: Label -> String
- Sound.SC3.UGen.Type: ugenName :: Primitive -> String
- Sound.SC3.UGen.Type: ugenOutputs :: Primitive -> [Output]
- Sound.SC3.UGen.Type: ugenRate :: Primitive -> Rate
- Sound.SC3.UGen.Type: ugenSpecial :: Primitive -> Special
- Sound.SC3.UGen.UGen: buffer_nframes :: UGen -> UGen
- Sound.SC3.UGen.UGen: equal_length_p :: [[a]] -> Bool
- Sound.SC3.UGen.UGen: primitive_is_pv_rate :: String -> Bool
- Sound.SC3.UGen.UGen: pv_track_buffer :: UGen -> Either String UGen
- Sound.SC3.UGen.UGen: pv_track_nframes :: UGen -> Either String UGen
- Sound.SC3.UGen.UGen: sep_first :: [t] -> Maybe (t, [t])
- Sound.SC3.UGen.UGen: sep_last :: [t] -> Maybe ([t], t)
- Sound.SC3.UGen.UGen: ugen_is_pv_rate :: UGen -> Bool
- Sound.SC3.UGen.UGen: ugen_primitive :: UGen -> [Primitive]
- Sound.SC3.UGen.UId: instance (Transport t, Functor io, Applicative io, MonadIO io) => UId (ReaderT t io)
- Sound.SC3.UGen.UId: instance UId IO
+ Sound.SC3.Common.Buffer: absdif :: Num a => a -> a -> a
+ Sound.SC3.Common.Buffer: blend :: Num a => a -> a -> a -> a
+ Sound.SC3.Common.Buffer: blendAt :: RealFrac a => a -> [a] -> a
+ Sound.SC3.Common.Buffer: blendAtBy :: (Integral i, RealFrac n) => (i -> t -> n) -> n -> t -> n
+ Sound.SC3.Common.Buffer: clipAt :: Int -> [a] -> a
+ Sound.SC3.Common.Buffer: from_wavetable :: Num n => [n] -> [n]
+ Sound.SC3.Common.Buffer: normalise_rng :: Fractional n => (n, n) -> (n, n) -> [n] -> [n]
+ Sound.SC3.Common.Buffer: normalize :: (Fractional n, Ord n) => n -> n -> [n] -> [n]
+ Sound.SC3.Common.Buffer: normalizeSum :: (Fractional a) => [a] -> [a]
+ Sound.SC3.Common.Buffer: resamp1 :: RealFrac n => Int -> [n] -> [n]
+ Sound.SC3.Common.Buffer: resamp1_gen :: (Integral i, RealFrac n) => i -> i -> (i -> t -> n) -> t -> i -> n
+ Sound.SC3.Common.Buffer: sineFill :: (Ord n, Floating n, Enum n) => Int -> [n] -> [n] -> [n]
+ Sound.SC3.Common.Buffer: sineGen :: (Floating n, Enum n) => Int -> [n] -> [n] -> [[n]]
+ Sound.SC3.Common.Buffer: t2_adjacent :: [t] -> [(t, t)]
+ Sound.SC3.Common.Buffer: t2_concat :: [(a, a)] -> [a]
+ Sound.SC3.Common.Buffer: t2_overlap :: [b] -> [(b, b)]
+ Sound.SC3.Common.Buffer: t2_window :: Integral i => i -> [t] -> [(t, t)]
+ Sound.SC3.Common.Buffer: to_wavetable :: Num a => [a] -> [a]
+ Sound.SC3.Common.Buffer.Array: blendAt :: RealFrac a => a -> Array Int a -> a
+ Sound.SC3.Common.Buffer.Array: clipAt :: Int -> Array Int a -> a
+ Sound.SC3.Common.Buffer.Array: resamp1 :: RealFrac n => Int -> Array Int n -> Array Int n
+ Sound.SC3.Common.Buffer.Gen: cheby :: (Enum n, Floating n, Ord n) => Int -> [n] -> [n]
+ Sound.SC3.Common.Buffer.Gen: gen_cheby :: (Enum n, Floating n, Ord n, Integral i) => i -> [n] -> [n]
+ Sound.SC3.Common.Buffer.Gen: nrm_u :: (Fractional n, Ord n) => [n] -> [n]
+ Sound.SC3.Common.Buffer.Gen: sine1 :: (Enum n, Floating n) => Int -> [n] -> [n]
+ Sound.SC3.Common.Buffer.Gen: sine1_l :: (Enum n, Floating n) => Int -> [n] -> [[n]]
+ Sound.SC3.Common.Buffer.Gen: sine1_nrm :: (Enum n, Floating n, Ord n) => Int -> [n] -> [n]
+ Sound.SC3.Common.Buffer.Gen: sine1_p :: (Enum n, Floating n) => Int -> (n, n) -> [n]
+ Sound.SC3.Common.Buffer.Gen: sine2 :: (Enum n, Floating n) => Int -> [(n, n)] -> [n]
+ Sound.SC3.Common.Buffer.Gen: sine2_l :: (Enum n, Floating n) => Int -> [(n, n)] -> [[n]]
+ Sound.SC3.Common.Buffer.Gen: sine2_nrm :: (Enum n, Floating n, Ord n) => Int -> [n] -> [n]
+ Sound.SC3.Common.Buffer.Gen: sine3 :: (Enum n, Floating n) => Int -> [(n, n, n)] -> [n]
+ Sound.SC3.Common.Buffer.Gen: sine3_l :: (Enum n, Floating n) => Int -> [(n, n, n)] -> [[n]]
+ Sound.SC3.Common.Buffer.Gen: sine3_p :: (Enum n, Floating n) => Int -> (n, n, n) -> [n]
+ Sound.SC3.Common.Buffer.Gen: sum_l :: Num n => [[n]] -> [n]
+ Sound.SC3.Common.Buffer.Vector: blendAt :: RealFrac a => a -> Vector a -> a
+ Sound.SC3.Common.Buffer.Vector: clipAt :: Int -> Vector a -> a
+ Sound.SC3.Common.Buffer.Vector: resamp1 :: RealFrac n => Int -> Vector n -> Vector n
+ Sound.SC3.Common.Envelope: ADSR :: a -> a -> a -> a -> a -> Envelope_Curve3 a -> a -> ADSR a
+ Sound.SC3.Common.Envelope: ADSSR :: a -> a -> a -> a -> a -> a -> a -> Envelope_Curve4 a -> a -> ADSSR a
+ Sound.SC3.Common.Envelope: ASR :: a -> a -> a -> Envelope_Curve2 a -> ASR a
+ Sound.SC3.Common.Envelope: EnvCub :: Envelope_Curve a
+ Sound.SC3.Common.Envelope: EnvExp :: Envelope_Curve a
+ Sound.SC3.Common.Envelope: EnvHold :: Envelope_Curve a
+ Sound.SC3.Common.Envelope: EnvLin :: Envelope_Curve a
+ Sound.SC3.Common.Envelope: EnvNum :: a -> Envelope_Curve a
+ Sound.SC3.Common.Envelope: EnvSin :: Envelope_Curve a
+ Sound.SC3.Common.Envelope: EnvSqr :: Envelope_Curve a
+ Sound.SC3.Common.Envelope: EnvStep :: Envelope_Curve a
+ Sound.SC3.Common.Envelope: EnvWelch :: Envelope_Curve a
+ Sound.SC3.Common.Envelope: Envelope :: [a] -> [a] -> [Envelope_Curve a] -> Maybe Int -> Maybe Int -> Envelope a
+ Sound.SC3.Common.Envelope: LINEN :: a -> a -> a -> a -> Envelope_Curve3 a -> LINEN a
+ Sound.SC3.Common.Envelope: [adsr_attackTime] :: ADSR a -> a
+ Sound.SC3.Common.Envelope: [adsr_bias] :: ADSR a -> a
+ Sound.SC3.Common.Envelope: [adsr_curve] :: ADSR a -> Envelope_Curve3 a
+ Sound.SC3.Common.Envelope: [adsr_decayTime] :: ADSR a -> a
+ Sound.SC3.Common.Envelope: [adsr_peakLevel] :: ADSR a -> a
+ Sound.SC3.Common.Envelope: [adsr_releaseTime] :: ADSR a -> a
+ Sound.SC3.Common.Envelope: [adsr_sustainLevel] :: ADSR a -> a
+ Sound.SC3.Common.Envelope: [adssr_attackLevel] :: ADSSR a -> a
+ Sound.SC3.Common.Envelope: [adssr_attackTime] :: ADSSR a -> a
+ Sound.SC3.Common.Envelope: [adssr_bias] :: ADSSR a -> a
+ Sound.SC3.Common.Envelope: [adssr_curve] :: ADSSR a -> Envelope_Curve4 a
+ Sound.SC3.Common.Envelope: [adssr_decayLevel] :: ADSSR a -> a
+ Sound.SC3.Common.Envelope: [adssr_decayTime] :: ADSSR a -> a
+ Sound.SC3.Common.Envelope: [adssr_releaseTime] :: ADSSR a -> a
+ Sound.SC3.Common.Envelope: [adssr_slopeTime] :: ADSSR a -> a
+ Sound.SC3.Common.Envelope: [adssr_sustainLevel] :: ADSSR a -> a
+ Sound.SC3.Common.Envelope: [asr_attackTime] :: ASR a -> a
+ Sound.SC3.Common.Envelope: [asr_curve] :: ASR a -> Envelope_Curve2 a
+ Sound.SC3.Common.Envelope: [asr_releaseTime] :: ASR a -> a
+ Sound.SC3.Common.Envelope: [asr_sustainLevel] :: ASR a -> a
+ Sound.SC3.Common.Envelope: [env_curves] :: Envelope a -> [Envelope_Curve a]
+ Sound.SC3.Common.Envelope: [env_levels] :: Envelope a -> [a]
+ Sound.SC3.Common.Envelope: [env_loop_node] :: Envelope a -> Maybe Int
+ Sound.SC3.Common.Envelope: [env_release_node] :: Envelope a -> Maybe Int
+ Sound.SC3.Common.Envelope: [env_times] :: Envelope a -> [a]
+ Sound.SC3.Common.Envelope: [linen_attackTime] :: LINEN a -> a
+ Sound.SC3.Common.Envelope: [linen_curve] :: LINEN a -> Envelope_Curve3 a
+ Sound.SC3.Common.Envelope: [linen_level] :: LINEN a -> a
+ Sound.SC3.Common.Envelope: [linen_releaseTime] :: LINEN a -> a
+ Sound.SC3.Common.Envelope: [linen_sustainTime] :: LINEN a -> a
+ Sound.SC3.Common.Envelope: adsrDefault :: Fractional n => ADSR n
+ Sound.SC3.Common.Envelope: data ADSR a
+ Sound.SC3.Common.Envelope: data ADSSR a
+ Sound.SC3.Common.Envelope: data ASR a
+ Sound.SC3.Common.Envelope: data Envelope a
+ Sound.SC3.Common.Envelope: data Envelope_Curve a
+ Sound.SC3.Common.Envelope: data LINEN a
+ Sound.SC3.Common.Envelope: envADSR :: Num a => a -> a -> a -> a -> a -> Envelope_Curve a -> a -> Envelope a
+ Sound.SC3.Common.Envelope: envADSR' :: Num a => a -> a -> a -> a -> Envelope a
+ Sound.SC3.Common.Envelope: envADSR_r :: Num a => ADSR a -> Envelope a
+ Sound.SC3.Common.Envelope: envADSSR :: Num a => a -> a -> a -> a -> a -> a -> a -> Envelope_Curve a -> a -> Envelope a
+ Sound.SC3.Common.Envelope: envADSSR_r :: Num a => ADSSR a -> Envelope a
+ Sound.SC3.Common.Envelope: envASR :: Num a => a -> a -> a -> Envelope_Curve a -> Envelope a
+ Sound.SC3.Common.Envelope: envASR_c :: Num a => a -> a -> a -> Envelope_Curve2 a -> Envelope a
+ Sound.SC3.Common.Envelope: envASR_r :: Num a => ASR a -> Envelope a
+ Sound.SC3.Common.Envelope: envCoord :: Num a => [(a, a)] -> a -> a -> Envelope_Curve a -> Envelope a
+ Sound.SC3.Common.Envelope: envLinen :: Num a => a -> a -> a -> a -> Envelope a
+ Sound.SC3.Common.Envelope: envLinen' :: Num a => a -> a -> a -> a -> Envelope_Curve3 a -> Envelope a
+ Sound.SC3.Common.Envelope: envLinen_r :: Num a => LINEN a -> Envelope a
+ Sound.SC3.Common.Envelope: envPerc :: Num a => a -> a -> Envelope a
+ Sound.SC3.Common.Envelope: envPerc' :: Num a => a -> a -> a -> Envelope_Curve2 a -> Envelope a
+ Sound.SC3.Common.Envelope: envSine :: Fractional a => a -> a -> Envelope a
+ Sound.SC3.Common.Envelope: envStep :: [a] -> [a] -> Maybe Int -> Maybe Int -> Envelope a
+ Sound.SC3.Common.Envelope: envTrapezoid_f :: Num t => (t -> t -> t, t -> t -> t) -> t -> t -> t -> t -> Envelope t
+ Sound.SC3.Common.Envelope: envTriangle :: Fractional a => a -> a -> Envelope a
+ Sound.SC3.Common.Envelope: env_circle :: Fractional a => Envelope a -> a -> Envelope_Curve a -> Envelope a
+ Sound.SC3.Common.Envelope: env_curve_coerce :: (a -> b) -> Envelope_Curve a -> Envelope_Curve b
+ Sound.SC3.Common.Envelope: env_curve_interpolation_f :: (Ord t, Floating t) => Envelope_Curve t -> Interpolation_F t
+ Sound.SC3.Common.Envelope: env_curve_shape :: Num a => Envelope_Curve a -> a
+ Sound.SC3.Common.Envelope: env_curve_value :: Num a => Envelope_Curve a -> a
+ Sound.SC3.Common.Envelope: env_delay :: Envelope a -> a -> Envelope a
+ Sound.SC3.Common.Envelope: env_is_sustained :: Envelope a -> Bool
+ Sound.SC3.Common.Envelope: envelope :: [a] -> [a] -> [Envelope_Curve a] -> Envelope a
+ Sound.SC3.Common.Envelope: envelope_at :: (Ord t, Floating t) => Envelope t -> t -> t
+ Sound.SC3.Common.Envelope: envelope_coerce :: (a -> b) -> Envelope a -> Envelope b
+ Sound.SC3.Common.Envelope: envelope_curves :: Envelope a -> [Envelope_Curve a]
+ Sound.SC3.Common.Envelope: envelope_duration :: Num n => Envelope n -> n
+ Sound.SC3.Common.Envelope: envelope_is_normal :: (Eq n, Num n) => Envelope n -> Bool
+ Sound.SC3.Common.Envelope: envelope_n_segments :: Integral i => Envelope n -> i
+ Sound.SC3.Common.Envelope: envelope_normalise :: (Num a, Ord a) => Envelope a -> Envelope a
+ Sound.SC3.Common.Envelope: envelope_render :: (Ord t, Floating t, Enum t) => t -> Envelope t -> [(t, t)]
+ Sound.SC3.Common.Envelope: envelope_sc3_array :: Num a => Envelope a -> Maybe [a]
+ Sound.SC3.Common.Envelope: envelope_sc3_ienvgen_array :: Num a => Envelope a -> Maybe [a]
+ Sound.SC3.Common.Envelope: envelope_segment :: Num t => Envelope t -> Int -> Envelope_Segment t
+ Sound.SC3.Common.Envelope: envelope_segment_ix :: (Ord a, Num a) => Envelope a -> a -> Maybe Int
+ Sound.SC3.Common.Envelope: envelope_segments :: Num t => Envelope t -> [Envelope_Segment t]
+ Sound.SC3.Common.Envelope: envelope_table :: (Ord t, Floating t, Enum t) => t -> Envelope t -> [t]
+ Sound.SC3.Common.Envelope: instance GHC.Classes.Eq a => GHC.Classes.Eq (Sound.SC3.Common.Envelope.Envelope a)
+ Sound.SC3.Common.Envelope: instance GHC.Classes.Eq a => GHC.Classes.Eq (Sound.SC3.Common.Envelope.Envelope_Curve a)
+ Sound.SC3.Common.Envelope: instance GHC.Show.Show a => GHC.Show.Show (Sound.SC3.Common.Envelope.Envelope a)
+ Sound.SC3.Common.Envelope: instance GHC.Show.Show a => GHC.Show.Show (Sound.SC3.Common.Envelope.Envelope_Curve a)
+ Sound.SC3.Common.Envelope: pack_envelope_segments :: Num t => [Envelope_Segment t] -> ([t], [t], [Envelope_Curve t])
+ Sound.SC3.Common.Envelope: type Envelope_Curve2 a = T2 (Envelope_Curve a)
+ Sound.SC3.Common.Envelope: type Envelope_Curve3 a = T3 (Envelope_Curve a)
+ Sound.SC3.Common.Envelope: type Envelope_Curve4 a = T4 (Envelope_Curve a)
+ Sound.SC3.Common.Envelope: type Envelope_Segment t = (t, t, t, t, Envelope_Curve t)
+ Sound.SC3.Common.Math: Clip_Both :: Clip_Rule
+ Sound.SC3.Common.Math: Clip_Left :: Clip_Rule
+ Sound.SC3.Common.Math: Clip_None :: Clip_Rule
+ Sound.SC3.Common.Math: Clip_Right :: Clip_Rule
+ Sound.SC3.Common.Math: amp_to_db :: Floating a => a -> a
+ Sound.SC3.Common.Math: apply_clip_rule :: Ord n => Clip_Rule -> n -> n -> n -> n -> n -> Maybe n
+ Sound.SC3.Common.Math: bin_to_freq :: (Fractional n, Integral i) => n -> i -> i -> n
+ Sound.SC3.Common.Math: clip_hs :: (Ord a) => (a, a) -> a -> a
+ Sound.SC3.Common.Math: cps_to_incr :: Fractional a => a -> a -> a -> a
+ Sound.SC3.Common.Math: cps_to_midi :: Floating a => a -> a
+ Sound.SC3.Common.Math: cps_to_oct :: Floating a => a -> a
+ Sound.SC3.Common.Math: data Clip_Rule
+ Sound.SC3.Common.Math: db_to_amp :: Floating a => a -> a
+ Sound.SC3.Common.Math: fmod_f32 :: Float -> Float -> Float
+ Sound.SC3.Common.Math: fmod_f64 :: Double -> Double -> Double
+ Sound.SC3.Common.Math: foldToRange :: (Ord a, Num a) => a -> a -> a -> a
+ Sound.SC3.Common.Math: fold_ :: (Ord a, Num a) => a -> a -> a -> a
+ Sound.SC3.Common.Math: generic_wrap :: (Ord a, Num a) => (a, a) -> a -> a
+ Sound.SC3.Common.Math: half_pi :: Floating a => a
+ Sound.SC3.Common.Math: incr_to_cps :: Fractional a => a -> a -> a -> a
+ Sound.SC3.Common.Math: instance GHC.Enum.Bounded Sound.SC3.Common.Math.Clip_Rule
+ Sound.SC3.Common.Math: instance GHC.Enum.Enum Sound.SC3.Common.Math.Clip_Rule
+ Sound.SC3.Common.Math: lin_exp :: Floating a => a -> a -> a -> a -> a -> a
+ Sound.SC3.Common.Math: lin_pan2 :: Fractional t => t -> t -> (t, t)
+ Sound.SC3.Common.Math: linexp_hs :: Floating a => (a, a) -> (a, a) -> a -> a
+ Sound.SC3.Common.Math: linlin :: Fractional a => a -> a -> a -> a -> a -> a
+ Sound.SC3.Common.Math: linlin_enum :: (Enum t, Enum u) => (t, t) -> (u, u) -> t -> Maybe u
+ Sound.SC3.Common.Math: linlin_enum' :: (Enum t, Enum u) => t -> u -> t -> u
+ Sound.SC3.Common.Math: linlin_enum_err :: (Enum t, Enum u) => (t, t) -> (u, u) -> t -> u
+ Sound.SC3.Common.Math: linlin_eq :: (Eq a, Num a) => (a, a) -> (a, a) -> a -> Maybe a
+ Sound.SC3.Common.Math: linlin_eq_err :: (Eq a, Num a) => (a, a) -> (a, a) -> a -> a
+ Sound.SC3.Common.Math: linlin_hs :: Fractional a => (a, a) -> (a, a) -> a -> a
+ Sound.SC3.Common.Math: linlin_muladd :: Fractional t => t -> t -> t -> t -> (t, t)
+ Sound.SC3.Common.Math: midi_to_cps :: Floating a => a -> a
+ Sound.SC3.Common.Math: midi_to_ratio :: Floating a => a -> a
+ Sound.SC3.Common.Math: mul_add_hs :: Num a => a -> a -> a -> a
+ Sound.SC3.Common.Math: oct_to_cps :: Floating a => a -> a
+ Sound.SC3.Common.Math: range :: Fractional a => a -> a -> a -> a
+ Sound.SC3.Common.Math: range_hs :: Fractional a => (a, a) -> a -> a
+ Sound.SC3.Common.Math: range_muladd :: Fractional t => t -> t -> (t, t)
+ Sound.SC3.Common.Math: ratio_to_midi :: Floating a => a -> a
+ Sound.SC3.Common.Math: sc3_idiv :: RealFrac n => n -> n -> n
+ Sound.SC3.Common.Math: sc3_mod :: RealFrac n => n -> n -> n
+ Sound.SC3.Common.Math: sc3_properFraction :: RealFrac t => t -> (t, t)
+ Sound.SC3.Common.Math: sc3_round_to :: RealFrac n => n -> n -> n
+ Sound.SC3.Common.Math: sc_ceiling :: RealFrac a => a -> a
+ Sound.SC3.Common.Math: sc_clip :: Ord a => a -> a -> a -> a
+ Sound.SC3.Common.Math: sc_curvelin :: (Ord a, Floating a) => a -> a -> a -> a -> a -> a -> a
+ Sound.SC3.Common.Math: sc_dif_sqr :: Num a => a -> a -> a
+ Sound.SC3.Common.Math: sc_expexp :: (Ord a, Floating a) => a -> a -> a -> a -> a -> a
+ Sound.SC3.Common.Math: sc_explin :: (Ord a, Floating a) => a -> a -> a -> a -> a -> a
+ Sound.SC3.Common.Math: sc_floor :: RealFrac a => a -> a
+ Sound.SC3.Common.Math: sc_hypot :: Floating a => a -> a -> a
+ Sound.SC3.Common.Math: sc_hypotx :: (Ord a, Floating a) => a -> a -> a
+ Sound.SC3.Common.Math: sc_lincurve :: (Ord a, Floating a) => a -> a -> a -> a -> a -> a -> a
+ Sound.SC3.Common.Math: sc_linexp :: (Ord a, Floating a) => a -> a -> a -> a -> a -> a
+ Sound.SC3.Common.Math: sc_mod :: RealFrac a => a -> a -> a
+ Sound.SC3.Common.Math: sc_round :: RealFrac a => a -> a
+ Sound.SC3.Common.Math: sc_truncate :: RealFrac a => a -> a
+ Sound.SC3.Common.Math: sc_wrap :: RealFrac n => n -> n -> n -> n
+ Sound.SC3.Common.Math: sc_wrap_ni :: RealFrac a => a -> a -> a -> a
+ Sound.SC3.Common.Math: two_pi :: Floating n => n
+ Sound.SC3.Common.Math: urange :: Fractional a => a -> a -> a -> a
+ Sound.SC3.Common.Math: wrap_hs :: RealFrac n => (n, n) -> n -> n
+ Sound.SC3.Common.Math.Interpolate: cubed :: Floating t => Interpolation_F t
+ Sound.SC3.Common.Math.Interpolate: curve :: (Ord t, Floating t) => t -> Interpolation_F t
+ Sound.SC3.Common.Math.Interpolate: exponential :: Floating t => Interpolation_F t
+ Sound.SC3.Common.Math.Interpolate: exponential' :: (Eq t, Floating t) => Interpolation_F t
+ Sound.SC3.Common.Math.Interpolate: exponential'' :: (Eq t, Floating t) => Interpolation_F t
+ Sound.SC3.Common.Math.Interpolate: hold :: (Num t, Ord t) => Interpolation_F t
+ Sound.SC3.Common.Math.Interpolate: interpolate :: (Num t, Ord t) => Interpolation_F t -> (t, t) -> t -> t
+ Sound.SC3.Common.Math.Interpolate: linear :: Num t => Interpolation_F t
+ Sound.SC3.Common.Math.Interpolate: sine :: Floating t => Interpolation_F t
+ Sound.SC3.Common.Math.Interpolate: squared :: Floating t => Interpolation_F t
+ Sound.SC3.Common.Math.Interpolate: step :: Interpolation_F t
+ Sound.SC3.Common.Math.Interpolate: type Interpolation_F t = t -> t -> t -> t
+ Sound.SC3.Common.Math.Interpolate: welch :: (Ord t, Floating t) => Interpolation_F t
+ Sound.SC3.Common.Math.Window: gaussian :: Floating a => a -> Window a
+ Sound.SC3.Common.Math.Window: gaussian_table :: (Integral n, Floating b, Enum b) => n -> b -> [b]
+ Sound.SC3.Common.Math.Window: hamming :: Floating a => Window a
+ Sound.SC3.Common.Math.Window: hamming_table :: Int -> [Double]
+ Sound.SC3.Common.Math.Window: hann :: Floating a => Window a
+ Sound.SC3.Common.Math.Window: hann_table :: Int -> [Double]
+ Sound.SC3.Common.Math.Window: rectangular :: Window a
+ Sound.SC3.Common.Math.Window: sine :: Floating a => Window a
+ Sound.SC3.Common.Math.Window: sine_table :: (Integral n, Floating b, Enum b) => n -> [b]
+ Sound.SC3.Common.Math.Window: square :: Num a => a -> a
+ Sound.SC3.Common.Math.Window: triangular :: Fractional a => Window a
+ Sound.SC3.Common.Math.Window: triangular_table :: (Integral n, Fractional b, Enum b) => n -> [b]
+ Sound.SC3.Common.Math.Window: type Table x = [x]
+ Sound.SC3.Common.Math.Window: type Window x = x -> x
+ Sound.SC3.Common.Math.Window: window_table :: (Integral n, Fractional a, Enum a) => n -> Window a -> Table a
+ Sound.SC3.Common.Monad: chainM :: Monad m => Int -> (b -> m b) -> b -> m b
+ Sound.SC3.Common.Monad: composeM :: Monad m => [a -> m a] -> a -> m a
+ Sound.SC3.Common.Monad: repeatM :: Monad m => m t -> m [t]
+ Sound.SC3.Common.Monad: repeatM_ :: Monad m => m t -> m ()
+ Sound.SC3.Common.Monad.Operators: (*.) :: (Functor f, Num a) => a -> f a -> f a
+ Sound.SC3.Common.Monad.Operators: (+.) :: (Functor f, Num a) => a -> f a -> f a
+ Sound.SC3.Common.Monad.Operators: (-.) :: (Functor f, Num a) => a -> f a -> f a
+ Sound.SC3.Common.Monad.Operators: (.*) :: (Functor f, Num a) => f a -> a -> f a
+ Sound.SC3.Common.Monad.Operators: (.*.) :: (Applicative m, Num a) => m a -> m a -> m a
+ Sound.SC3.Common.Monad.Operators: (.+) :: (Functor f, Num a) => f a -> a -> f a
+ Sound.SC3.Common.Monad.Operators: (.+.) :: (Applicative m, Num a) => m a -> m a -> m a
+ Sound.SC3.Common.Monad.Operators: (.-) :: (Functor f, Num a) => f a -> a -> f a
+ Sound.SC3.Common.Monad.Operators: (.-.) :: (Applicative m, Num a) => m a -> m a -> m a
+ Sound.SC3.Common.Monad.Operators: (./) :: (Functor f, Fractional a) => f a -> a -> f a
+ Sound.SC3.Common.Monad.Operators: (./.) :: (Applicative m, Fractional a) => m a -> m a -> m a
+ Sound.SC3.Common.Monad.Operators: (/.) :: (Functor f, Fractional a) => a -> f a -> f a
+ Sound.SC3.Common.Monad.Operators: infixl 6 .-.
+ Sound.SC3.Common.Monad.Operators: infixl 7 ./.
+ Sound.SC3.Common.Prelude: CI :: Case_Rule
+ Sound.SC3.Common.Prelude: CS :: Case_Rule
+ Sound.SC3.Common.Prelude: d_dx :: (Num a) => [a] -> [a]
+ Sound.SC3.Common.Prelude: d_dx' :: Num n => [n] -> [n]
+ Sound.SC3.Common.Prelude: data Case_Rule
+ Sound.SC3.Common.Prelude: dup2 :: t -> T2 t
+ Sound.SC3.Common.Prelude: dup3 :: t -> T3 t
+ Sound.SC3.Common.Prelude: dup4 :: t -> T4 t
+ Sound.SC3.Common.Prelude: dx_d :: Num n => [n] -> [n]
+ Sound.SC3.Common.Prelude: dx_d' :: Num n => [n] -> [n]
+ Sound.SC3.Common.Prelude: equal_length_p :: [[a]] -> Bool
+ Sound.SC3.Common.Prelude: histogram :: Ord a => [a] -> [(a, Int)]
+ Sound.SC3.Common.Prelude: instance GHC.Classes.Eq Sound.SC3.Common.Prelude.Case_Rule
+ Sound.SC3.Common.Prelude: is_ci :: Case_Rule -> Bool
+ Sound.SC3.Common.Prelude: is_cs :: Case_Rule -> Bool
+ Sound.SC3.Common.Prelude: lookup_by :: (a -> a -> Bool) -> a -> [(a, b)] -> Maybe b
+ Sound.SC3.Common.Prelude: mk_duples :: (a -> c) -> (b -> c) -> [(a, b)] -> [c]
+ Sound.SC3.Common.Prelude: mk_duples_l :: (Int -> c) -> (a -> c) -> (b -> c) -> [(a, [b])] -> [c]
+ Sound.SC3.Common.Prelude: mk_triples :: (a -> d) -> (b -> d) -> (c -> d) -> [(a, b, c)] -> [d]
+ Sound.SC3.Common.Prelude: parse_enum :: (Show t, Enum t, Bounded t) => Case_Rule -> String -> Maybe t
+ Sound.SC3.Common.Prelude: pcn_triples :: [a] -> [(Maybe a, a, Maybe a)]
+ Sound.SC3.Common.Prelude: reads_exact :: Read a => String -> Maybe a
+ Sound.SC3.Common.Prelude: rlookup_by :: (b -> b -> Bool) -> b -> [(a, b)] -> Maybe a
+ Sound.SC3.Common.Prelude: rlookup_str :: Case_Rule -> String -> [(a, String)] -> Maybe a
+ Sound.SC3.Common.Prelude: sep_first :: [t] -> Maybe (t, [t])
+ Sound.SC3.Common.Prelude: sep_last :: [t] -> Maybe ([t], t)
+ Sound.SC3.Common.Prelude: string_eq :: Case_Rule -> String -> String -> Bool
+ Sound.SC3.Common.Prelude: type T2 a = (a, a)
+ Sound.SC3.Common.Prelude: type T3 a = (a, a, a)
+ Sound.SC3.Common.Prelude: type T4 a = (a, a, a, a)
+ Sound.SC3.Server.Command.Completion: b_alloc :: Packet -> Int -> Int -> Int -> Message
+ Sound.SC3.Server.Command.Completion: b_allocRead :: Packet -> Int -> String -> Int -> Int -> Message
+ Sound.SC3.Server.Command.Completion: b_allocReadChannel :: Packet -> Int -> String -> Int -> Int -> [Int] -> Message
+ Sound.SC3.Server.Command.Completion: b_close :: Packet -> Int -> Message
+ Sound.SC3.Server.Command.Completion: b_free :: Packet -> Int -> Message
+ Sound.SC3.Server.Command.Completion: b_read :: Packet -> Int -> String -> Int -> Int -> Int -> Bool -> Message
+ Sound.SC3.Server.Command.Completion: b_readChannel :: Packet -> Int -> String -> Int -> Int -> Int -> Bool -> [Int] -> Message
+ Sound.SC3.Server.Command.Completion: b_write :: Packet -> Int -> String -> SoundFileFormat -> SampleFormat -> Int -> Int -> Bool -> Message
+ Sound.SC3.Server.Command.Completion: b_zero :: Packet -> Int -> Message
+ Sound.SC3.Server.Command.Completion: d_load :: Packet -> String -> Message
+ Sound.SC3.Server.Command.Completion: d_loadDir :: Packet -> String -> Message
+ Sound.SC3.Server.Command.Completion: d_recv :: Packet -> Synthdef -> Message
+ Sound.SC3.Server.Command.Completion: encode_blob :: Packet -> Datum
+ Sound.SC3.Server.Command.Enum: b_info_fields :: [(String, String)]
+ Sound.SC3.Server.Command.Enum: n_info_fields :: [(String, String, String)]
+ Sound.SC3.Server.Command.Generic: b_setn1_segmented :: (Integral i, Real n) => i -> i -> i -> [n] -> [Message]
+ Sound.SC3.Server.Command.Generic: n_run1 :: Integral i => i -> Bool -> Message
+ Sound.SC3.Server.Command.Generic: unpack_b_info :: (Num i, Fractional f) => Message -> Maybe (i, i, i, f)
+ Sound.SC3.Server.Command.Generic: unpack_b_info_err :: (Num i, Fractional f) => Message -> (i, i, i, f)
+ Sound.SC3.Server.Command.Generic: unpack_b_setn :: (Num i, Fractional f) => Message -> Maybe (i, i, i, [f])
+ Sound.SC3.Server.Command.Generic: unpack_b_setn_err :: (Num i, Fractional f) => Message -> (i, i, i, [f])
+ Sound.SC3.Server.Command.Generic: unpack_n_info :: Num i => Message -> Maybe (i, i, i, i, i, Maybe (i, i))
+ Sound.SC3.Server.Command.Generic: unpack_n_info_datum_plain :: Num i => [Datum] -> [i]
+ Sound.SC3.Server.Command.Generic: unpack_n_info_err :: Num i => Message -> (i, i, i, i, i, Maybe (i, i))
+ Sound.SC3.Server.Command.Generic: unpack_n_info_plain :: Num i => Message -> [i]
+ Sound.SC3.Server.Command.Generic: unpack_tr :: (Num i, Fractional f) => Message -> Maybe (i, i, f)
+ Sound.SC3.Server.Command.Generic: unpack_tr_err :: (Num i, Fractional f) => Message -> (i, i, f)
+ Sound.SC3.Server.Command.Generic: with_completion_packet :: Message -> Packet -> Message
+ Sound.SC3.Server.Command.Plain: b_setn1_segmented :: Int -> Buffer_Id -> Buffer_Ix -> [Double] -> [Message]
+ Sound.SC3.Server.Command.Plain: n_run1 :: Node_Id -> Bool -> Message
+ Sound.SC3.Server.Command.Plain: type Buffer_Id = Int
+ Sound.SC3.Server.Command.Plain: type Buffer_Ix = Int
+ Sound.SC3.Server.Command.Plain: type Buffer_Leave_File_Open = Bool
+ Sound.SC3.Server.Command.Plain: type Bus_Id = Int
+ Sound.SC3.Server.Command.Plain: type Group_Id = Int
+ Sound.SC3.Server.Command.Plain: type Node_Id = Int
+ Sound.SC3.Server.Command.Plain: type Synth_Id = Int
+ Sound.SC3.Server.Command.Plain: unpack_b_info :: Message -> Maybe (Int, Int, Int, Double)
+ Sound.SC3.Server.Command.Plain: unpack_b_info_err :: Message -> (Int, Int, Int, Double)
+ Sound.SC3.Server.Command.Plain: unpack_b_setn :: Message -> Maybe (Int, Int, Int, [Double])
+ Sound.SC3.Server.Command.Plain: unpack_b_setn_err :: Message -> (Int, Int, Int, [Double])
+ Sound.SC3.Server.Command.Plain: unpack_n_info :: Message -> Maybe (Int, Int, Int, Int, Int, Maybe (Int, Int))
+ Sound.SC3.Server.Command.Plain: unpack_n_info_err :: Message -> (Int, Int, Int, Int, Int, Maybe (Int, Int))
+ Sound.SC3.Server.Command.Plain: unpack_n_info_plain :: Message -> [Int]
+ Sound.SC3.Server.Command.Plain: unpack_tr :: Message -> Maybe (Int, Int, Double)
+ Sound.SC3.Server.Command.Plain: unpack_tr_err :: Message -> (Int, Int, Double)
+ Sound.SC3.Server.Enum: instance GHC.Classes.Eq Sound.SC3.Server.Enum.AddAction
+ Sound.SC3.Server.Enum: instance GHC.Classes.Eq Sound.SC3.Server.Enum.B_Gen
+ Sound.SC3.Server.Enum: instance GHC.Classes.Eq Sound.SC3.Server.Enum.ErrorMode
+ Sound.SC3.Server.Enum: instance GHC.Classes.Eq Sound.SC3.Server.Enum.ErrorScope
+ Sound.SC3.Server.Enum: instance GHC.Classes.Eq Sound.SC3.Server.Enum.PrintLevel
+ Sound.SC3.Server.Enum: instance GHC.Classes.Eq Sound.SC3.Server.Enum.SampleFormat
+ Sound.SC3.Server.Enum: instance GHC.Classes.Eq Sound.SC3.Server.Enum.SoundFileFormat
+ Sound.SC3.Server.Enum: instance GHC.Enum.Bounded Sound.SC3.Server.Enum.B_Gen
+ Sound.SC3.Server.Enum: instance GHC.Enum.Enum Sound.SC3.Server.Enum.AddAction
+ Sound.SC3.Server.Enum: instance GHC.Enum.Enum Sound.SC3.Server.Enum.B_Gen
+ Sound.SC3.Server.Enum: instance GHC.Enum.Enum Sound.SC3.Server.Enum.ErrorMode
+ Sound.SC3.Server.Enum: instance GHC.Enum.Enum Sound.SC3.Server.Enum.ErrorScope
+ Sound.SC3.Server.Enum: instance GHC.Enum.Enum Sound.SC3.Server.Enum.PrintLevel
+ Sound.SC3.Server.Enum: instance GHC.Enum.Enum Sound.SC3.Server.Enum.SampleFormat
+ Sound.SC3.Server.Enum: instance GHC.Enum.Enum Sound.SC3.Server.Enum.SoundFileFormat
+ Sound.SC3.Server.Enum: instance GHC.Read.Read Sound.SC3.Server.Enum.SampleFormat
+ Sound.SC3.Server.Enum: instance GHC.Read.Read Sound.SC3.Server.Enum.SoundFileFormat
+ Sound.SC3.Server.Enum: instance GHC.Show.Show Sound.SC3.Server.Enum.AddAction
+ Sound.SC3.Server.Enum: instance GHC.Show.Show Sound.SC3.Server.Enum.B_Gen
+ Sound.SC3.Server.Enum: instance GHC.Show.Show Sound.SC3.Server.Enum.ErrorMode
+ Sound.SC3.Server.Enum: instance GHC.Show.Show Sound.SC3.Server.Enum.ErrorScope
+ Sound.SC3.Server.Enum: instance GHC.Show.Show Sound.SC3.Server.Enum.PrintLevel
+ Sound.SC3.Server.Enum: instance GHC.Show.Show Sound.SC3.Server.Enum.SampleFormat
+ Sound.SC3.Server.Enum: instance GHC.Show.Show Sound.SC3.Server.Enum.SoundFileFormat
+ Sound.SC3.Server.Graphdef: [graphdef_constants] :: Graphdef -> [Sample]
+ Sound.SC3.Server.Graphdef: [graphdef_controls] :: Graphdef -> [(Control, Sample)]
+ Sound.SC3.Server.Graphdef: [graphdef_name] :: Graphdef -> Name
+ Sound.SC3.Server.Graphdef: [graphdef_ugens] :: Graphdef -> [UGen]
+ Sound.SC3.Server.Graphdef: instance GHC.Classes.Eq Sound.SC3.Server.Graphdef.Graphdef
+ Sound.SC3.Server.Graphdef: instance GHC.Classes.Eq Sound.SC3.Server.Graphdef.Input
+ Sound.SC3.Server.Graphdef: instance GHC.Show.Show Sound.SC3.Server.Graphdef.Graphdef
+ Sound.SC3.Server.Graphdef: instance GHC.Show.Show Sound.SC3.Server.Graphdef.Input
+ Sound.SC3.Server.NRT: [nrt_bundles] :: NRT -> [Bundle]
+ Sound.SC3.Server.NRT: instance GHC.Show.Show Sound.SC3.Server.NRT.NRT
+ Sound.SC3.Server.NRT: nrt_stat :: NRT -> NRT_STAT
+ Sound.SC3.Server.NRT: type NRT_STAT = ((String, Time), (String, Int), (String, Int), (String, [(String, Int)]))
+ Sound.SC3.Server.NRT.Edit: nrt_append :: NRT -> NRT -> NRT
+ Sound.SC3.Server.Recorder: [rec_buf_frames] :: SC3_Recorder -> Int
+ Sound.SC3.Server.Recorder: [rec_buf_id] :: SC3_Recorder -> Int
+ Sound.SC3.Server.Recorder: [rec_bus] :: SC3_Recorder -> Int
+ Sound.SC3.Server.Recorder: [rec_coding] :: SC3_Recorder -> SampleFormat
+ Sound.SC3.Server.Recorder: [rec_dur] :: SC3_Recorder -> Maybe Time
+ Sound.SC3.Server.Recorder: [rec_fname] :: SC3_Recorder -> FilePath
+ Sound.SC3.Server.Recorder: [rec_group_id] :: SC3_Recorder -> Int
+ Sound.SC3.Server.Recorder: [rec_nc] :: SC3_Recorder -> Int
+ Sound.SC3.Server.Recorder: [rec_node_id] :: SC3_Recorder -> Int
+ Sound.SC3.Server.Recorder: [rec_sftype] :: SC3_Recorder -> SoundFileFormat
+ Sound.SC3.Server.Recorder: instance Data.Default.Class.Default Sound.SC3.Server.Recorder.SC3_Recorder
+ Sound.SC3.Server.Recorder: rec_synthdef_nm :: Int -> String
+ Sound.SC3.Server.Status: instance GHC.Classes.Eq Sound.SC3.Server.Status.Query_Node
+ Sound.SC3.Server.Status: instance GHC.Show.Show Sound.SC3.Server.Status.Query_Node
+ Sound.SC3.Server.Status: queryNode_to_group_seq :: Query_Node -> [Int]
+ Sound.SC3.Server.Synthdef: [synthdefName] :: Synthdef -> String
+ Sound.SC3.Server.Synthdef: [synthdefUGen] :: Synthdef -> UGen
+ Sound.SC3.Server.Synthdef: instance Data.Default.Class.Default Sound.SC3.Server.Synthdef.Synthdef
+ Sound.SC3.Server.Synthdef: instance GHC.Classes.Eq Sound.SC3.Server.Synthdef.Synthdef
+ Sound.SC3.Server.Synthdef: instance GHC.Show.Show Sound.SC3.Server.Synthdef.Synthdef
+ Sound.SC3.Server.Synthdef: synthstat' :: UGen -> [String]
+ Sound.SC3.Server.Transport.FD: b_fetch1 :: Transport t => t -> Int -> Int -> IO [Double]
+ Sound.SC3.Server.Transport.FD: instance Sound.SC3.Server.Transport.FD.Audible Sound.SC3.Server.Graphdef.Graphdef
+ Sound.SC3.Server.Transport.FD: instance Sound.SC3.Server.Transport.FD.Audible Sound.SC3.Server.Synthdef.Synthdef
+ Sound.SC3.Server.Transport.FD: instance Sound.SC3.Server.Transport.FD.Audible Sound.SC3.UGen.Type.UGen
+ Sound.SC3.Server.Transport.FD: maybe_async :: (Transport t) => t -> Message -> IO ()
+ Sound.SC3.Server.Transport.FD: maybe_async_at :: (Transport t) => t -> Time -> Message -> IO ()
+ Sound.SC3.Server.Transport.FD: nrt_audition :: NRT -> IO ()
+ Sound.SC3.Server.Transport.FD: nrt_play :: Transport t => t -> NRT -> IO ()
+ Sound.SC3.Server.Transport.Monad: async_ :: DuplexOSC m => Message -> m ()
+ Sound.SC3.Server.Transport.Monad: b_fetch1 :: DuplexOSC m => Int -> Int -> m [Double]
+ Sound.SC3.Server.Transport.Monad: b_fetch_hdr :: Transport m => Int -> Int -> m ((Int, Int, Int, Double), [[Double]])
+ Sound.SC3.Server.Transport.Monad: b_query1_unpack :: DuplexOSC m => Buffer_Id -> m (Int, Int, Int, Double)
+ Sound.SC3.Server.Transport.Monad: b_query1_unpack_generic :: (DuplexOSC m, Num n, Fractional r) => Int -> m (n, n, n, r)
+ Sound.SC3.Server.Transport.Monad: g_queryTree1_unpack :: Transport m => Group_Id -> m Query_Node
+ Sound.SC3.Server.Transport.Monad: instance Sound.SC3.Server.Transport.Monad.Audible Sound.SC3.Server.Graphdef.Graphdef
+ Sound.SC3.Server.Transport.Monad: instance Sound.SC3.Server.Transport.Monad.Audible Sound.SC3.Server.Synthdef.Synthdef
+ Sound.SC3.Server.Transport.Monad: instance Sound.SC3.Server.Transport.Monad.Audible Sound.SC3.UGen.Type.UGen
+ Sound.SC3.Server.Transport.Monad: maybe_async :: DuplexOSC m => Message -> m ()
+ Sound.SC3.Server.Transport.Monad: maybe_async_at :: DuplexOSC m => Time -> Message -> m ()
+ Sound.SC3.Server.Transport.Monad: n_query1_unpack :: Transport m => Node_Id -> m (Maybe (Int, Int, Int, Int, Int, Maybe (Int, Int)))
+ Sound.SC3.Server.Transport.Monad: n_query1_unpack_f :: Transport m => (Message -> t) -> Node_Id -> m t
+ Sound.SC3.Server.Transport.Monad: n_query1_unpack_plain :: Transport m => Node_Id -> m [Int]
+ Sound.SC3.Server.Transport.Monad: nrt_audition :: NRT -> IO ()
+ Sound.SC3.Server.Transport.Monad: nrt_play :: Transport m => NRT -> m ()
+ Sound.SC3.Server.Transport.Monad: nrt_play_reorder :: Transport m => NRT -> m ()
+ Sound.SC3.Server.Transport.Monad: play_graphdef_msg :: Play_Opt -> Graphdef -> Message
+ Sound.SC3.Server.Transport.Monad: play_synthdef_msg :: Play_Opt -> Synthdef -> Message
+ Sound.SC3.Server.Transport.Monad: sc3_default_udp :: IO UDP
+ Sound.SC3.Server.Transport.Monad: type Play_Opt = (Node_Id, AddAction, Group_Id, [(String, Double)])
+ Sound.SC3.Server.Transport.Monad: withSC3_ :: Connection UDP a -> IO ()
+ Sound.SC3.UGen.Analysis: buffer_nframes :: UGen -> UGen
+ Sound.SC3.UGen.Analysis: primitive_is_pv_rate :: String -> Bool
+ Sound.SC3.UGen.Analysis: pv_track_buffer :: UGen -> Either String UGen
+ Sound.SC3.UGen.Analysis: pv_track_nframes :: UGen -> Either String UGen
+ Sound.SC3.UGen.Analysis: ugen_is_pv_rate :: UGen -> Bool
+ Sound.SC3.UGen.Analysis: ugen_primitive :: UGen -> [Primitive]
+ Sound.SC3.UGen.Bindings.Composite: klanx_spec_f :: (a -> [b]) -> ([b] -> c) -> a -> a -> a -> c
+ Sound.SC3.UGen.Bindings.Composite: rand0 :: ID a => a -> UGen -> UGen
+ Sound.SC3.UGen.Bindings.Composite: rand0M :: UId m => UGen -> m UGen
+ Sound.SC3.UGen.Bindings.Composite: rand2 :: ID a => a -> UGen -> UGen
+ Sound.SC3.UGen.Bindings.Composite: rand2M :: UId m => UGen -> m UGen
+ Sound.SC3.UGen.Bindings.Composite: triAS :: Int -> UGen -> UGen
+ Sound.SC3.UGen.Bindings.DB: fbSineC :: Rate -> UGen -> UGen -> UGen -> UGen -> UGen -> UGen -> UGen -> UGen
+ Sound.SC3.UGen.Bindings.DB: fbSineL :: Rate -> UGen -> UGen -> UGen -> UGen -> UGen -> UGen -> UGen -> UGen
+ Sound.SC3.UGen.Bindings.DB: fbSineN :: Rate -> UGen -> UGen -> UGen -> UGen -> UGen -> UGen -> UGen -> UGen
+ Sound.SC3.UGen.Bindings.HW.External.SC3_Plugins: lfBrownNoise0 :: ID a => a -> Rate -> UGen -> UGen -> UGen -> UGen
+ Sound.SC3.UGen.Bindings.HW.External.SC3_Plugins: lfBrownNoise1 :: ID a => a -> Rate -> UGen -> UGen -> UGen -> UGen
+ Sound.SC3.UGen.Bindings.HW.External.SC3_Plugins: lfBrownNoise2 :: ID a => a -> Rate -> UGen -> UGen -> UGen -> UGen
+ Sound.SC3.UGen.Bindings.HW.External.Zita: [zr1_delay] :: ZitaRev1 a -> a
+ Sound.SC3.UGen.Bindings.HW.External.Zita: [zr1_eq1fr] :: ZitaRev1 a -> a
+ Sound.SC3.UGen.Bindings.HW.External.Zita: [zr1_eq1gn] :: ZitaRev1 a -> a
+ Sound.SC3.UGen.Bindings.HW.External.Zita: [zr1_eq2fr] :: ZitaRev1 a -> a
+ Sound.SC3.UGen.Bindings.HW.External.Zita: [zr1_eq2gn] :: ZitaRev1 a -> a
+ Sound.SC3.UGen.Bindings.HW.External.Zita: [zr1_fdamp] :: ZitaRev1 a -> a
+ Sound.SC3.UGen.Bindings.HW.External.Zita: [zr1_in1] :: ZitaRev1 a -> a
+ Sound.SC3.UGen.Bindings.HW.External.Zita: [zr1_in2] :: ZitaRev1 a -> a
+ Sound.SC3.UGen.Bindings.HW.External.Zita: [zr1_level] :: ZitaRev1 a -> a
+ Sound.SC3.UGen.Bindings.HW.External.Zita: [zr1_opmix] :: ZitaRev1 a -> a
+ Sound.SC3.UGen.Bindings.HW.External.Zita: [zr1_rtlow] :: ZitaRev1 a -> a
+ Sound.SC3.UGen.Bindings.HW.External.Zita: [zr1_rtmid] :: ZitaRev1 a -> a
+ Sound.SC3.UGen.Bindings.HW.External.Zita: [zr1_xover] :: ZitaRev1 a -> a
+ Sound.SC3.UGen.Enum: data Loop' t
+ Sound.SC3.UGen.Enum: instance GHC.Classes.Eq Sound.SC3.UGen.Enum.Buffer
+ Sound.SC3.UGen.Enum: instance GHC.Classes.Eq Sound.SC3.UGen.Enum.DoneAction
+ Sound.SC3.UGen.Enum: instance GHC.Classes.Eq Sound.SC3.UGen.Enum.Interpolation
+ Sound.SC3.UGen.Enum: instance GHC.Classes.Eq Sound.SC3.UGen.Enum.Warp
+ Sound.SC3.UGen.Enum: instance GHC.Classes.Eq t => GHC.Classes.Eq (Sound.SC3.UGen.Enum.Loop' t)
+ Sound.SC3.UGen.Enum: instance GHC.Show.Show Sound.SC3.UGen.Enum.Buffer
+ Sound.SC3.UGen.Enum: instance GHC.Show.Show Sound.SC3.UGen.Enum.DoneAction
+ Sound.SC3.UGen.Enum: instance GHC.Show.Show Sound.SC3.UGen.Enum.Interpolation
+ Sound.SC3.UGen.Enum: instance GHC.Show.Show Sound.SC3.UGen.Enum.Warp
+ Sound.SC3.UGen.Enum: instance GHC.Show.Show t => GHC.Show.Show (Sound.SC3.UGen.Enum.Loop' t)
+ Sound.SC3.UGen.Enum: type Loop = Loop' UGen
+ Sound.SC3.UGen.Envelope: envGate :: UGen -> UGen -> UGen -> DoneAction -> Envelope_Curve UGen -> UGen
+ Sound.SC3.UGen.Envelope: envGate' :: UGen
+ Sound.SC3.UGen.Envelope: envTrapezoid :: OrdE t => t -> t -> t -> t -> Envelope t
+ Sound.SC3.UGen.Graph: [constants] :: Graph -> [Node]
+ Sound.SC3.UGen.Graph: [controls] :: Graph -> [Node]
+ Sound.SC3.UGen.Graph: [nextId] :: Graph -> NodeId
+ Sound.SC3.UGen.Graph: [node_c_value] :: Node -> Sample
+ Sound.SC3.UGen.Graph: [node_id] :: Node -> NodeId
+ Sound.SC3.UGen.Graph: [node_k_default] :: Node -> Sample
+ Sound.SC3.UGen.Graph: [node_k_index] :: Node -> Maybe Int
+ Sound.SC3.UGen.Graph: [node_k_meta] :: Node -> Maybe (C_Meta Sample)
+ Sound.SC3.UGen.Graph: [node_k_name] :: Node -> String
+ Sound.SC3.UGen.Graph: [node_k_rate] :: Node -> Rate
+ Sound.SC3.UGen.Graph: [node_k_type] :: Node -> KType
+ Sound.SC3.UGen.Graph: [node_p_index] :: Node -> PortIndex
+ Sound.SC3.UGen.Graph: [node_p_node] :: Node -> Node
+ Sound.SC3.UGen.Graph: [node_u_inputs] :: Node -> [FromPort]
+ Sound.SC3.UGen.Graph: [node_u_name] :: Node -> String
+ Sound.SC3.UGen.Graph: [node_u_outputs] :: Node -> [Output]
+ Sound.SC3.UGen.Graph: [node_u_rate] :: Node -> Rate
+ Sound.SC3.UGen.Graph: [node_u_special] :: Node -> Special
+ Sound.SC3.UGen.Graph: [node_u_ugenid] :: Node -> UGenId
+ Sound.SC3.UGen.Graph: [port_idx] :: FromPort -> Maybe PortIndex
+ Sound.SC3.UGen.Graph: [port_kt] :: FromPort -> KType
+ Sound.SC3.UGen.Graph: [port_nid] :: FromPort -> NodeId
+ Sound.SC3.UGen.Graph: [ugens] :: Graph -> [Node]
+ Sound.SC3.UGen.Graph: instance GHC.Classes.Eq Sound.SC3.UGen.Graph.FromPort
+ Sound.SC3.UGen.Graph: instance GHC.Classes.Eq Sound.SC3.UGen.Graph.KType
+ Sound.SC3.UGen.Graph: instance GHC.Classes.Eq Sound.SC3.UGen.Graph.ToPort
+ Sound.SC3.UGen.Graph: instance GHC.Classes.Ord Sound.SC3.UGen.Graph.KType
+ Sound.SC3.UGen.Graph: instance GHC.Show.Show Sound.SC3.UGen.Graph.FromPort
+ Sound.SC3.UGen.Graph: instance GHC.Show.Show Sound.SC3.UGen.Graph.Graph
+ Sound.SC3.UGen.Graph: instance GHC.Show.Show Sound.SC3.UGen.Graph.KType
+ Sound.SC3.UGen.Graph: instance GHC.Show.Show Sound.SC3.UGen.Graph.Node
+ Sound.SC3.UGen.Graph: instance GHC.Show.Show Sound.SC3.UGen.Graph.ToPort
+ Sound.SC3.UGen.Graph: node_rate :: Node -> Rate
+ Sound.SC3.UGen.Graph.Reconstruct: reconstruct_graph :: Graph -> ([String], String)
+ Sound.SC3.UGen.Graph.Reconstruct: reconstruct_graph_module :: String -> Graph -> [String]
+ Sound.SC3.UGen.HS: as_trig :: (Fractional t, Ord t) => F_ST1 t t Bool
+ Sound.SC3.UGen.HS: avg2 :: Fractional n => F_U2 n
+ Sound.SC3.UGen.HS: avg3 :: Fractional n => F_U3 n
+ Sound.SC3.UGen.HS: avg4 :: Fractional n => F_U4 n
+ Sound.SC3.UGen.HS: avg5 :: Fractional n => F_U5 n
+ Sound.SC3.UGen.HS: avg9 :: Fractional n => F_U9 n
+ Sound.SC3.UGen.HS: biquad :: F_U5 n -> F_ST1 (T4 n) n n
+ Sound.SC3.UGen.HS: bpz2 :: Fractional n => F_ST1 (T2 n) n n
+ Sound.SC3.UGen.HS: brown_noise :: (RandomGen g, Fractional n, Random n, Ord n) => F_ST0 (g, n) n
+ Sound.SC3.UGen.HS: brown_noise_f :: (Fractional n, Ord n) => n -> n -> n
+ Sound.SC3.UGen.HS: brz2 :: Fractional n => F_ST1 (T2 n) n n
+ Sound.SC3.UGen.HS: bw_hpf_ir :: Floating n => T2 n -> F_ST1 (T4 n) n n
+ Sound.SC3.UGen.HS: bw_lpf_ir :: Floating n => T2 n -> F_ST1 (T4 n) n n
+ Sound.SC3.UGen.HS: bw_lpf_or_hpf_coef :: Floating n => Bool -> n -> n -> T5 n
+ Sound.SC3.UGen.HS: decay_f :: Floating a => a -> a -> a -> a -> a
+ Sound.SC3.UGen.HS: fir1 :: F_U2 n -> F_ST1 n n n
+ Sound.SC3.UGen.HS: fir2 :: F_U3 n -> F_ST1 (T2 n) n n
+ Sound.SC3.UGen.HS: fir3 :: F_U4 n -> F_ST1 (T3 n) n n
+ Sound.SC3.UGen.HS: fir4 :: F_U5 n -> F_ST1 (T4 n) n n
+ Sound.SC3.UGen.HS: fir8 :: F_U9 n -> F_ST1 (T8 n) n n
+ Sound.SC3.UGen.HS: hpz1 :: Fractional n => F_ST1 n n n
+ Sound.SC3.UGen.HS: hpz2 :: Fractional n => F_ST1 (T2 n) n n
+ Sound.SC3.UGen.HS: iir1 :: F_U2 n -> F_ST1 n n n
+ Sound.SC3.UGen.HS: iir2 :: F_U3 n -> F_ST1 (T2 n) n n
+ Sound.SC3.UGen.HS: iir2_ff_fb :: (n -> n -> n -> T2 n) -> (n, T2 n) -> (n, T2 n)
+ Sound.SC3.UGen.HS: l_apply_f_st0 :: F_ST0 st o -> st -> [o]
+ Sound.SC3.UGen.HS: l_apply_f_st1 :: F_ST1 st i o -> st -> [i] -> [o]
+ Sound.SC3.UGen.HS: l_bpz2 :: Fractional n => [n] -> [n]
+ Sound.SC3.UGen.HS: l_brown_noise :: (Enum e, Fractional n, Ord n, Random n) => e -> [n]
+ Sound.SC3.UGen.HS: l_brz2 :: Fractional n => [n] -> [n]
+ Sound.SC3.UGen.HS: l_bw_hpf :: Floating n => T2 n -> [n] -> [n]
+ Sound.SC3.UGen.HS: l_bw_lpf :: Floating n => T2 n -> [n] -> [n]
+ Sound.SC3.UGen.HS: l_cos_osc :: (Floating n, RealFrac n) => n -> [n] -> [n]
+ Sound.SC3.UGen.HS: l_hpz1 :: Fractional n => [n] -> [n]
+ Sound.SC3.UGen.HS: l_hpz2 :: Fractional n => [n] -> [n]
+ Sound.SC3.UGen.HS: l_lag :: Floating t => t -> [t] -> [t] -> [t]
+ Sound.SC3.UGen.HS: l_lpz1 :: Fractional n => [n] -> [n]
+ Sound.SC3.UGen.HS: l_lpz2 :: Fractional n => [n] -> [n]
+ Sound.SC3.UGen.HS: l_mavg5 :: Fractional n => [n] -> [n]
+ Sound.SC3.UGen.HS: l_mavg9 :: Fractional n => [n] -> [n]
+ Sound.SC3.UGen.HS: l_phasor :: RealFrac n => [Bool] -> [n] -> [n] -> [n] -> [n] -> [n]
+ Sound.SC3.UGen.HS: l_phasor_osc :: RealFrac n => n -> n -> [n] -> [n]
+ Sound.SC3.UGen.HS: l_resonz_ir :: Floating n => T3 n -> [n] -> [n]
+ Sound.SC3.UGen.HS: l_rlpf_ir :: (Floating n, Ord n) => T3 n -> [n] -> [n]
+ Sound.SC3.UGen.HS: l_sin_osc :: (Floating n, RealFrac n) => n -> [n] -> [n]
+ Sound.SC3.UGen.HS: l_white_noise :: (Enum e, Fractional n, Random n) => e -> [n]
+ Sound.SC3.UGen.HS: lag :: Floating t => t -> F_ST1 t (t, t) t
+ Sound.SC3.UGen.HS: lag_f :: Floating a => a -> a -> a -> a -> a
+ Sound.SC3.UGen.HS: latch :: F_ST1 t (t, Bool) t
+ Sound.SC3.UGen.HS: lpz1 :: Fractional n => F_ST1 n n n
+ Sound.SC3.UGen.HS: lpz2 :: Fractional n => F_ST1 (T2 n) n n
+ Sound.SC3.UGen.HS: mavg5 :: Fractional n => F_ST1 (T4 n) n n
+ Sound.SC3.UGen.HS: mavg9 :: Fractional n => F_ST1 (T8 n) n n
+ Sound.SC3.UGen.HS: phasor :: RealFrac t => F_ST1 t (Bool, t, t, t, t) t
+ Sound.SC3.UGen.HS: resonz_f :: Floating n => T3 n -> (n -> n -> n -> T2 n)
+ Sound.SC3.UGen.HS: resonz_ir :: Floating n => T3 n -> F_ST1 (T2 n) n n
+ Sound.SC3.UGen.HS: rlpf_f :: Floating n => (n -> n -> n) -> T3 n -> F_U3 n
+ Sound.SC3.UGen.HS: rlpf_ir :: (Floating n, Ord n) => T3 n -> F_ST1 (T2 n) n n
+ Sound.SC3.UGen.HS: sos :: Num n => T5 n -> F_ST1 (T4 n) n n
+ Sound.SC3.UGen.HS: sos_f :: Num n => T5 n -> F_U5 n
+ Sound.SC3.UGen.HS: sr_to_rps :: Floating n => n -> n
+ Sound.SC3.UGen.HS: type F_ST0 st o = st -> (o, st)
+ Sound.SC3.UGen.HS: type F_ST1 st i o = (i, st) -> (o, st)
+ Sound.SC3.UGen.HS: type F_U2 n = n -> n -> n
+ Sound.SC3.UGen.HS: type F_U3 n = n -> n -> n -> n
+ Sound.SC3.UGen.HS: type F_U4 n = n -> n -> n -> n -> n
+ Sound.SC3.UGen.HS: type F_U5 n = n -> n -> n -> n -> n -> n
+ Sound.SC3.UGen.HS: type F_U6 n = n -> n -> n -> n -> n -> n -> n
+ Sound.SC3.UGen.HS: type F_U7 n = n -> n -> n -> n -> n -> n -> n -> n
+ Sound.SC3.UGen.HS: type F_U8 n = n -> n -> n -> n -> n -> n -> n -> n -> n
+ Sound.SC3.UGen.HS: type F_U9 n = n -> n -> n -> n -> n -> n -> n -> n -> n -> n
+ Sound.SC3.UGen.HS: type T2 n = (n, n)
+ Sound.SC3.UGen.HS: type T3 n = (n, n, n)
+ Sound.SC3.UGen.HS: type T4 n = (n, n, n, n)
+ Sound.SC3.UGen.HS: type T5 n = (n, n, n, n, n)
+ Sound.SC3.UGen.HS: type T6 n = (n, n, n, n, n, n)
+ Sound.SC3.UGen.HS: type T7 n = (n, n, n, n, n, n, n)
+ Sound.SC3.UGen.HS: type T8 n = (n, n, n, n, n, n, n, n)
+ Sound.SC3.UGen.HS: type T9 n = (n, n, n, n, n, n, n, n, n)
+ Sound.SC3.UGen.HS: white_noise :: (RandomGen g, Fractional n, Random n) => F_ST0 g n
+ Sound.SC3.UGen.Identifier: instance Sound.SC3.UGen.Identifier.ID GHC.Integer.Type.Integer
+ Sound.SC3.UGen.Identifier: instance Sound.SC3.UGen.Identifier.ID GHC.Types.Char
+ Sound.SC3.UGen.Identifier: instance Sound.SC3.UGen.Identifier.ID GHC.Types.Double
+ Sound.SC3.UGen.Identifier: instance Sound.SC3.UGen.Identifier.ID GHC.Types.Float
+ Sound.SC3.UGen.Identifier: instance Sound.SC3.UGen.Identifier.ID GHC.Types.Int
+ Sound.SC3.UGen.MCE: instance GHC.Classes.Eq n => GHC.Classes.Eq (Sound.SC3.UGen.MCE.MCE n)
+ Sound.SC3.UGen.MCE: instance GHC.Num.Num n => GHC.Num.Num (Sound.SC3.UGen.MCE.MCE n)
+ Sound.SC3.UGen.MCE: instance GHC.Read.Read n => GHC.Read.Read (Sound.SC3.UGen.MCE.MCE n)
+ Sound.SC3.UGen.MCE: instance GHC.Real.Fractional n => GHC.Real.Fractional (Sound.SC3.UGen.MCE.MCE n)
+ Sound.SC3.UGen.MCE: instance GHC.Show.Show n => GHC.Show.Show (Sound.SC3.UGen.MCE.MCE n)
+ Sound.SC3.UGen.Math: class Num a => MulAdd a where mul_add i m a = i * m + a
+ Sound.SC3.UGen.Math: instance Sound.SC3.UGen.Math.BinaryOp GHC.Types.Double
+ Sound.SC3.UGen.Math: instance Sound.SC3.UGen.Math.BinaryOp GHC.Types.Float
+ Sound.SC3.UGen.Math: instance Sound.SC3.UGen.Math.BinaryOp Sound.SC3.UGen.Type.UGen
+ Sound.SC3.UGen.Math: instance Sound.SC3.UGen.Math.EqE GHC.Int.Int32
+ Sound.SC3.UGen.Math: instance Sound.SC3.UGen.Math.EqE GHC.Int.Int64
+ Sound.SC3.UGen.Math: instance Sound.SC3.UGen.Math.EqE GHC.Integer.Type.Integer
+ Sound.SC3.UGen.Math: instance Sound.SC3.UGen.Math.EqE GHC.Types.Double
+ Sound.SC3.UGen.Math: instance Sound.SC3.UGen.Math.EqE GHC.Types.Float
+ Sound.SC3.UGen.Math: instance Sound.SC3.UGen.Math.EqE GHC.Types.Int
+ Sound.SC3.UGen.Math: instance Sound.SC3.UGen.Math.EqE Sound.SC3.UGen.Type.UGen
+ Sound.SC3.UGen.Math: instance Sound.SC3.UGen.Math.MulAdd GHC.Types.Double
+ Sound.SC3.UGen.Math: instance Sound.SC3.UGen.Math.MulAdd GHC.Types.Float
+ Sound.SC3.UGen.Math: instance Sound.SC3.UGen.Math.MulAdd Sound.SC3.UGen.Type.UGen
+ Sound.SC3.UGen.Math: instance Sound.SC3.UGen.Math.OrdE GHC.Int.Int32
+ Sound.SC3.UGen.Math: instance Sound.SC3.UGen.Math.OrdE GHC.Int.Int64
+ Sound.SC3.UGen.Math: instance Sound.SC3.UGen.Math.OrdE GHC.Integer.Type.Integer
+ Sound.SC3.UGen.Math: instance Sound.SC3.UGen.Math.OrdE GHC.Types.Double
+ Sound.SC3.UGen.Math: instance Sound.SC3.UGen.Math.OrdE GHC.Types.Float
+ Sound.SC3.UGen.Math: instance Sound.SC3.UGen.Math.OrdE GHC.Types.Int
+ Sound.SC3.UGen.Math: instance Sound.SC3.UGen.Math.OrdE Sound.SC3.UGen.Type.UGen
+ Sound.SC3.UGen.Math: instance Sound.SC3.UGen.Math.RealFracE GHC.Types.Double
+ Sound.SC3.UGen.Math: instance Sound.SC3.UGen.Math.RealFracE GHC.Types.Float
+ Sound.SC3.UGen.Math: instance Sound.SC3.UGen.Math.RealFracE Sound.SC3.UGen.Type.UGen
+ Sound.SC3.UGen.Math: instance Sound.SC3.UGen.Math.UnaryOp GHC.Types.Double
+ Sound.SC3.UGen.Math: instance Sound.SC3.UGen.Math.UnaryOp GHC.Types.Float
+ Sound.SC3.UGen.Math: instance Sound.SC3.UGen.Math.UnaryOp Sound.SC3.UGen.Type.UGen
+ Sound.SC3.UGen.Math: linlin_ma :: (Fractional a, MulAdd a) => a -> a -> a -> a -> a -> a
+ Sound.SC3.UGen.Math: range_ma :: (Fractional a, MulAdd a) => a -> a -> a -> a
+ Sound.SC3.UGen.Math: urange_ma :: (Fractional a, MulAdd a) => a -> a -> a -> a
+ Sound.SC3.UGen.Math.Composite: ugen_fmidi_to_midi_detune :: UGen -> UGen
+ Sound.SC3.UGen.Math.Composite: ugen_if :: Num a => a -> a -> a -> a
+ Sound.SC3.UGen.Math.Composite: ugen_integral_and_fractional_parts :: UGen -> UGen
+ Sound.SC3.UGen.Operator: instance GHC.Classes.Eq Sound.SC3.UGen.Operator.Binary
+ Sound.SC3.UGen.Operator: instance GHC.Classes.Eq Sound.SC3.UGen.Operator.Unary
+ Sound.SC3.UGen.Operator: instance GHC.Enum.Bounded Sound.SC3.UGen.Operator.Binary
+ Sound.SC3.UGen.Operator: instance GHC.Enum.Bounded Sound.SC3.UGen.Operator.Unary
+ Sound.SC3.UGen.Operator: instance GHC.Enum.Enum Sound.SC3.UGen.Operator.Binary
+ Sound.SC3.UGen.Operator: instance GHC.Enum.Enum Sound.SC3.UGen.Operator.Unary
+ Sound.SC3.UGen.Operator: instance GHC.Read.Read Sound.SC3.UGen.Operator.Binary
+ Sound.SC3.UGen.Operator: instance GHC.Read.Read Sound.SC3.UGen.Operator.Unary
+ Sound.SC3.UGen.Operator: instance GHC.Show.Show Sound.SC3.UGen.Operator.Binary
+ Sound.SC3.UGen.Operator: instance GHC.Show.Show Sound.SC3.UGen.Operator.Unary
+ Sound.SC3.UGen.Rate: instance GHC.Classes.Eq Sound.SC3.UGen.Rate.Rate
+ Sound.SC3.UGen.Rate: instance GHC.Classes.Ord Sound.SC3.UGen.Rate.Rate
+ Sound.SC3.UGen.Rate: instance GHC.Enum.Bounded Sound.SC3.UGen.Rate.Rate
+ Sound.SC3.UGen.Rate: instance GHC.Enum.Enum Sound.SC3.UGen.Rate.Rate
+ Sound.SC3.UGen.Rate: instance GHC.Read.Read Sound.SC3.UGen.Rate.Rate
+ Sound.SC3.UGen.Rate: instance GHC.Show.Show Sound.SC3.UGen.Rate.Rate
+ Sound.SC3.UGen.Type: [constantValue] :: Constant -> Sample
+ Sound.SC3.UGen.Type: [controlDefault] :: Control -> Sample
+ Sound.SC3.UGen.Type: [controlIndex] :: Control -> Maybe Int
+ Sound.SC3.UGen.Type: [controlMeta] :: Control -> Maybe (C_Meta Sample)
+ Sound.SC3.UGen.Type: [controlName] :: Control -> String
+ Sound.SC3.UGen.Type: [controlOperatingRate] :: Control -> Rate
+ Sound.SC3.UGen.Type: [controlTriggered] :: Control -> Bool
+ Sound.SC3.UGen.Type: [ctl_max] :: C_Meta n -> n
+ Sound.SC3.UGen.Type: [ctl_min] :: C_Meta n -> n
+ Sound.SC3.UGen.Type: [ctl_step] :: C_Meta n -> n
+ Sound.SC3.UGen.Type: [ctl_units] :: C_Meta n -> String
+ Sound.SC3.UGen.Type: [ctl_warp] :: C_Meta n -> String
+ Sound.SC3.UGen.Type: [mrgLeft] :: MRG -> UGen
+ Sound.SC3.UGen.Type: [mrgRight] :: MRG -> UGen
+ Sound.SC3.UGen.Type: [proxyIndex] :: Proxy -> Int
+ Sound.SC3.UGen.Type: [proxySource] :: Proxy -> Primitive
+ Sound.SC3.UGen.Type: [ugenId] :: Primitive -> UGenId
+ Sound.SC3.UGen.Type: [ugenInputs] :: Primitive -> [UGen]
+ Sound.SC3.UGen.Type: [ugenLabel] :: Label -> String
+ Sound.SC3.UGen.Type: [ugenName] :: Primitive -> String
+ Sound.SC3.UGen.Type: [ugenOutputs] :: Primitive -> [Output]
+ Sound.SC3.UGen.Type: [ugenRate] :: Primitive -> Rate
+ Sound.SC3.UGen.Type: [ugenSpecial] :: Primitive -> Special
+ Sound.SC3.UGen.Type: c_meta_t5 :: (n -> m) -> C_Meta_T5 n -> C_Meta m
+ Sound.SC3.UGen.Type: instance Data.Bits.Bits Sound.SC3.UGen.Type.UGen
+ Sound.SC3.UGen.Type: instance GHC.Classes.Eq Sound.SC3.UGen.Type.Constant
+ Sound.SC3.UGen.Type: instance GHC.Classes.Eq Sound.SC3.UGen.Type.Control
+ Sound.SC3.UGen.Type: instance GHC.Classes.Eq Sound.SC3.UGen.Type.Label
+ Sound.SC3.UGen.Type: instance GHC.Classes.Eq Sound.SC3.UGen.Type.MRG
+ Sound.SC3.UGen.Type: instance GHC.Classes.Eq Sound.SC3.UGen.Type.Primitive
+ Sound.SC3.UGen.Type: instance GHC.Classes.Eq Sound.SC3.UGen.Type.Proxy
+ Sound.SC3.UGen.Type: instance GHC.Classes.Eq Sound.SC3.UGen.Type.Special
+ Sound.SC3.UGen.Type: instance GHC.Classes.Eq Sound.SC3.UGen.Type.UGen
+ Sound.SC3.UGen.Type: instance GHC.Classes.Eq Sound.SC3.UGen.Type.UGenId
+ Sound.SC3.UGen.Type: instance GHC.Classes.Eq n => GHC.Classes.Eq (Sound.SC3.UGen.Type.C_Meta n)
+ Sound.SC3.UGen.Type: instance GHC.Classes.Ord Sound.SC3.UGen.Type.Constant
+ Sound.SC3.UGen.Type: instance GHC.Classes.Ord Sound.SC3.UGen.Type.UGen
+ Sound.SC3.UGen.Type: instance GHC.Enum.Enum Sound.SC3.UGen.Type.UGen
+ Sound.SC3.UGen.Type: instance GHC.Float.Floating Sound.SC3.UGen.Type.UGen
+ Sound.SC3.UGen.Type: instance GHC.Num.Num Sound.SC3.UGen.Type.UGen
+ Sound.SC3.UGen.Type: instance GHC.Read.Read Sound.SC3.UGen.Type.Constant
+ Sound.SC3.UGen.Type: instance GHC.Read.Read Sound.SC3.UGen.Type.Control
+ Sound.SC3.UGen.Type: instance GHC.Read.Read Sound.SC3.UGen.Type.Label
+ Sound.SC3.UGen.Type: instance GHC.Read.Read Sound.SC3.UGen.Type.MRG
+ Sound.SC3.UGen.Type: instance GHC.Read.Read Sound.SC3.UGen.Type.Primitive
+ Sound.SC3.UGen.Type: instance GHC.Read.Read Sound.SC3.UGen.Type.Proxy
+ Sound.SC3.UGen.Type: instance GHC.Read.Read Sound.SC3.UGen.Type.Special
+ Sound.SC3.UGen.Type: instance GHC.Read.Read Sound.SC3.UGen.Type.UGen
+ Sound.SC3.UGen.Type: instance GHC.Read.Read Sound.SC3.UGen.Type.UGenId
+ Sound.SC3.UGen.Type: instance GHC.Read.Read n => GHC.Read.Read (Sound.SC3.UGen.Type.C_Meta n)
+ Sound.SC3.UGen.Type: instance GHC.Real.Fractional Sound.SC3.UGen.Type.UGen
+ Sound.SC3.UGen.Type: instance GHC.Real.Integral Sound.SC3.UGen.Type.UGen
+ Sound.SC3.UGen.Type: instance GHC.Real.Real Sound.SC3.UGen.Type.UGen
+ Sound.SC3.UGen.Type: instance GHC.Real.RealFrac Sound.SC3.UGen.Type.UGen
+ Sound.SC3.UGen.Type: instance GHC.Show.Show Sound.SC3.UGen.Type.Constant
+ Sound.SC3.UGen.Type: instance GHC.Show.Show Sound.SC3.UGen.Type.Control
+ Sound.SC3.UGen.Type: instance GHC.Show.Show Sound.SC3.UGen.Type.Label
+ Sound.SC3.UGen.Type: instance GHC.Show.Show Sound.SC3.UGen.Type.MRG
+ Sound.SC3.UGen.Type: instance GHC.Show.Show Sound.SC3.UGen.Type.Primitive
+ Sound.SC3.UGen.Type: instance GHC.Show.Show Sound.SC3.UGen.Type.Proxy
+ Sound.SC3.UGen.Type: instance GHC.Show.Show Sound.SC3.UGen.Type.Special
+ Sound.SC3.UGen.Type: instance GHC.Show.Show Sound.SC3.UGen.Type.UGen
+ Sound.SC3.UGen.Type: instance GHC.Show.Show Sound.SC3.UGen.Type.UGenId
+ Sound.SC3.UGen.Type: instance GHC.Show.Show n => GHC.Show.Show (Sound.SC3.UGen.Type.C_Meta n)
+ Sound.SC3.UGen.Type: instance System.Random.Random Sound.SC3.UGen.Type.UGen
+ Sound.SC3.UGen.Type: mceDegree_err :: UGen -> Int
+ Sound.SC3.UGen.Type: mrg_leftmost :: UGen -> UGen
+ Sound.SC3.UGen.Type: parse_double :: String -> Maybe Double
+ Sound.SC3.UGen.Type: type C_Meta_T5 n = (n, n, String, n, String)
+ Sound.SC3.UGen.Type: u_constant_err :: UGen -> Sample
+ Sound.SC3.UGen.UGen: envelope_to_ugen :: Envelope UGen -> UGen
+ Sound.SC3.UGen.UGen: map_ix :: ((Int, a) -> b) -> [a] -> [b]
+ Sound.SC3.UGen.UGen: mce_map_ix :: ((Int, UGen) -> UGen) -> UGen -> UGen
+ Sound.SC3.UGen.UGen: t2_from_list :: [t] -> (t, t)
+ Sound.SC3.UGen.UGen: unmce2 :: UGen -> (UGen, UGen)
+ Sound.SC3.UGen.UId: instance Sound.SC3.UGen.UId.UId (Control.Monad.Trans.State.Lazy.StateT GHC.Types.Int Data.Functor.Identity.Identity)
+ Sound.SC3.UGen.UId: instance Sound.SC3.UGen.UId.UId GHC.Types.IO
+ Sound.SC3.UGen.UId: instance Sound.SC3.UGen.UId.UId m => Sound.SC3.UGen.UId.UId (Control.Monad.Trans.Reader.ReaderT t m)
+ Sound.SC3.UGen.UId: type UId_ST = State Int
+ Sound.SC3.UGen.UId: uid_st_eval :: UId_ST t -> t
+ Sound.SC3.UGen.UId: uid_st_seq :: [UId_ST t] -> ([t], Int)
+ Sound.SC3.UGen.UId: uid_st_seq_ :: [UId_ST t] -> [t]
- Sound.SC3.Server.Command.Generic: withCM :: OSC o => Message -> o -> Message
+ Sound.SC3.Server.Command.Generic: withCM :: Message -> Message -> Message
- Sound.SC3.Server.Command.Plain: b_alloc :: Int -> Int -> Int -> Message
+ Sound.SC3.Server.Command.Plain: b_alloc :: Buffer_Id -> Int -> Int -> Message
- Sound.SC3.Server.Command.Plain: b_allocRead :: Int -> String -> Int -> Int -> Message
+ Sound.SC3.Server.Command.Plain: b_allocRead :: Buffer_Id -> String -> Int -> Int -> Message
- Sound.SC3.Server.Command.Plain: b_allocReadChannel :: Int -> String -> Int -> Int -> [Int] -> Message
+ Sound.SC3.Server.Command.Plain: b_allocReadChannel :: Buffer_Id -> String -> Int -> Int -> [Int] -> Message
- Sound.SC3.Server.Command.Plain: b_alloc_setn1 :: Int -> Int -> [Double] -> Message
+ Sound.SC3.Server.Command.Plain: b_alloc_setn1 :: Buffer_Id -> Buffer_Ix -> [Double] -> Message
- Sound.SC3.Server.Command.Plain: b_close :: Int -> Message
+ Sound.SC3.Server.Command.Plain: b_close :: Buffer_Id -> Message
- Sound.SC3.Server.Command.Plain: b_fill :: Int -> [(Int, Int, Double)] -> Message
+ Sound.SC3.Server.Command.Plain: b_fill :: Buffer_Id -> [(Buffer_Ix, Int, Double)] -> Message
- Sound.SC3.Server.Command.Plain: b_free :: Int -> Message
+ Sound.SC3.Server.Command.Plain: b_free :: Buffer_Id -> Message
- Sound.SC3.Server.Command.Plain: b_gen :: Int -> String -> [Datum] -> Message
+ Sound.SC3.Server.Command.Plain: b_gen :: Buffer_Id -> String -> [Datum] -> Message
- Sound.SC3.Server.Command.Plain: b_gen_cheby :: Int -> [B_Gen] -> [Double] -> Message
+ Sound.SC3.Server.Command.Plain: b_gen_cheby :: Buffer_Id -> [B_Gen] -> [Double] -> Message
- Sound.SC3.Server.Command.Plain: b_gen_copy :: Int -> Int -> Int -> Int -> Maybe Int -> Message
+ Sound.SC3.Server.Command.Plain: b_gen_copy :: Buffer_Id -> Int -> Buffer_Id -> Int -> Maybe Int -> Message
- Sound.SC3.Server.Command.Plain: b_gen_sine1 :: Int -> [B_Gen] -> [Double] -> Message
+ Sound.SC3.Server.Command.Plain: b_gen_sine1 :: Buffer_Id -> [B_Gen] -> [Double] -> Message
- Sound.SC3.Server.Command.Plain: b_gen_sine2 :: Int -> [B_Gen] -> [(Double, Double)] -> Message
+ Sound.SC3.Server.Command.Plain: b_gen_sine2 :: Buffer_Id -> [B_Gen] -> [(Double, Double)] -> Message
- Sound.SC3.Server.Command.Plain: b_gen_sine3 :: Int -> [B_Gen] -> [(Double, Double, Double)] -> Message
+ Sound.SC3.Server.Command.Plain: b_gen_sine3 :: Buffer_Id -> [B_Gen] -> [(Double, Double, Double)] -> Message
- Sound.SC3.Server.Command.Plain: b_get :: Int -> [Int] -> Message
+ Sound.SC3.Server.Command.Plain: b_get :: Buffer_Id -> [Buffer_Ix] -> Message
- Sound.SC3.Server.Command.Plain: b_getn :: Int -> [(Int, Int)] -> Message
+ Sound.SC3.Server.Command.Plain: b_getn :: Buffer_Id -> [(Buffer_Ix, Int)] -> Message
- Sound.SC3.Server.Command.Plain: b_getn1 :: Int -> (Int, Int) -> Message
+ Sound.SC3.Server.Command.Plain: b_getn1 :: Buffer_Id -> (Buffer_Ix, Int) -> Message
- Sound.SC3.Server.Command.Plain: b_query :: [Int] -> Message
+ Sound.SC3.Server.Command.Plain: b_query :: [Buffer_Id] -> Message
- Sound.SC3.Server.Command.Plain: b_query1 :: Int -> Message
+ Sound.SC3.Server.Command.Plain: b_query1 :: Buffer_Id -> Message
- Sound.SC3.Server.Command.Plain: b_read :: Int -> String -> Int -> Int -> Int -> Bool -> Message
+ Sound.SC3.Server.Command.Plain: b_read :: Buffer_Id -> String -> Int -> Int -> Buffer_Ix -> Buffer_Leave_File_Open -> Message
- Sound.SC3.Server.Command.Plain: b_readChannel :: Int -> String -> Int -> Int -> Int -> Bool -> [Int] -> Message
+ Sound.SC3.Server.Command.Plain: b_readChannel :: Buffer_Id -> String -> Int -> Int -> Buffer_Ix -> Buffer_Leave_File_Open -> [Int] -> Message
- Sound.SC3.Server.Command.Plain: b_set :: Int -> [(Int, Double)] -> Message
+ Sound.SC3.Server.Command.Plain: b_set :: Buffer_Id -> [(Buffer_Ix, Double)] -> Message
- Sound.SC3.Server.Command.Plain: b_set1 :: Int -> Int -> Double -> Message
+ Sound.SC3.Server.Command.Plain: b_set1 :: Buffer_Id -> Buffer_Ix -> Double -> Message
- Sound.SC3.Server.Command.Plain: b_setn :: Int -> [(Int, [Double])] -> Message
+ Sound.SC3.Server.Command.Plain: b_setn :: Buffer_Id -> [(Buffer_Ix, [Double])] -> Message
- Sound.SC3.Server.Command.Plain: b_setn1 :: Int -> Int -> [Double] -> Message
+ Sound.SC3.Server.Command.Plain: b_setn1 :: Buffer_Id -> Buffer_Ix -> [Double] -> Message
- Sound.SC3.Server.Command.Plain: b_write :: Int -> String -> SoundFileFormat -> SampleFormat -> Int -> Int -> Bool -> Message
+ Sound.SC3.Server.Command.Plain: b_write :: Buffer_Id -> String -> SoundFileFormat -> SampleFormat -> Int -> Buffer_Ix -> Buffer_Leave_File_Open -> Message
- Sound.SC3.Server.Command.Plain: b_zero :: Int -> Message
+ Sound.SC3.Server.Command.Plain: b_zero :: Buffer_Id -> Message
- Sound.SC3.Server.Command.Plain: c_fill :: [(Int, Int, Double)] -> Message
+ Sound.SC3.Server.Command.Plain: c_fill :: [(Bus_Id, Int, Double)] -> Message
- Sound.SC3.Server.Command.Plain: c_get :: [Int] -> Message
+ Sound.SC3.Server.Command.Plain: c_get :: [Bus_Id] -> Message
- Sound.SC3.Server.Command.Plain: c_getn :: [(Int, Int)] -> Message
+ Sound.SC3.Server.Command.Plain: c_getn :: [(Bus_Id, Int)] -> Message
- Sound.SC3.Server.Command.Plain: c_getn1 :: (Int, Int) -> Message
+ Sound.SC3.Server.Command.Plain: c_getn1 :: (Bus_Id, Int) -> Message
- Sound.SC3.Server.Command.Plain: c_set :: [(Int, Double)] -> Message
+ Sound.SC3.Server.Command.Plain: c_set :: [(Bus_Id, Double)] -> Message
- Sound.SC3.Server.Command.Plain: c_set1 :: Int -> Double -> Message
+ Sound.SC3.Server.Command.Plain: c_set1 :: Bus_Id -> Double -> Message
- Sound.SC3.Server.Command.Plain: c_setn :: [(Int, [Double])] -> Message
+ Sound.SC3.Server.Command.Plain: c_setn :: [(Bus_Id, [Double])] -> Message
- Sound.SC3.Server.Command.Plain: c_setn1 :: (Int, [Double]) -> Message
+ Sound.SC3.Server.Command.Plain: c_setn1 :: (Bus_Id, [Double]) -> Message
- Sound.SC3.Server.Command.Plain: g_deepFree :: [Int] -> Message
+ Sound.SC3.Server.Command.Plain: g_deepFree :: [Group_Id] -> Message
- Sound.SC3.Server.Command.Plain: g_dumpTree :: [(Int, Bool)] -> Message
+ Sound.SC3.Server.Command.Plain: g_dumpTree :: [(Group_Id, Bool)] -> Message
- Sound.SC3.Server.Command.Plain: g_freeAll :: [Int] -> Message
+ Sound.SC3.Server.Command.Plain: g_freeAll :: [Group_Id] -> Message
- Sound.SC3.Server.Command.Plain: g_head :: [(Int, Int)] -> Message
+ Sound.SC3.Server.Command.Plain: g_head :: [(Group_Id, Node_Id)] -> Message
- Sound.SC3.Server.Command.Plain: g_new :: [(Int, AddAction, Int)] -> Message
+ Sound.SC3.Server.Command.Plain: g_new :: [(Group_Id, AddAction, Node_Id)] -> Message
- Sound.SC3.Server.Command.Plain: g_queryTree :: [(Int, Bool)] -> Message
+ Sound.SC3.Server.Command.Plain: g_queryTree :: [(Group_Id, Bool)] -> Message
- Sound.SC3.Server.Command.Plain: g_tail :: [(Int, Int)] -> Message
+ Sound.SC3.Server.Command.Plain: g_tail :: [(Group_Id, Node_Id)] -> Message
- Sound.SC3.Server.Command.Plain: n_after :: [(Int, Int)] -> Message
+ Sound.SC3.Server.Command.Plain: n_after :: [(Node_Id, Node_Id)] -> Message
- Sound.SC3.Server.Command.Plain: n_before :: [(Int, Int)] -> Message
+ Sound.SC3.Server.Command.Plain: n_before :: [(Node_Id, Node_Id)] -> Message
- Sound.SC3.Server.Command.Plain: n_fill :: Int -> [(String, Int, Double)] -> Message
+ Sound.SC3.Server.Command.Plain: n_fill :: Node_Id -> [(String, Int, Double)] -> Message
- Sound.SC3.Server.Command.Plain: n_free :: [Int] -> Message
+ Sound.SC3.Server.Command.Plain: n_free :: [Node_Id] -> Message
- Sound.SC3.Server.Command.Plain: n_map :: Int -> [(String, Int)] -> Message
+ Sound.SC3.Server.Command.Plain: n_map :: Node_Id -> [(String, Bus_Id)] -> Message
- Sound.SC3.Server.Command.Plain: n_mapa :: Int -> [(String, Int)] -> Message
+ Sound.SC3.Server.Command.Plain: n_mapa :: Node_Id -> [(String, Bus_Id)] -> Message
- Sound.SC3.Server.Command.Plain: n_mapan :: Int -> [(String, Int, Int)] -> Message
+ Sound.SC3.Server.Command.Plain: n_mapan :: Node_Id -> [(String, Bus_Id, Int)] -> Message
- Sound.SC3.Server.Command.Plain: n_mapn :: Int -> [(String, Int, Int)] -> Message
+ Sound.SC3.Server.Command.Plain: n_mapn :: Node_Id -> [(String, Bus_Id, Int)] -> Message
- Sound.SC3.Server.Command.Plain: n_order :: AddAction -> Int -> [Int] -> Message
+ Sound.SC3.Server.Command.Plain: n_order :: AddAction -> Node_Id -> [Node_Id] -> Message
- Sound.SC3.Server.Command.Plain: n_query :: [Int] -> Message
+ Sound.SC3.Server.Command.Plain: n_query :: [Node_Id] -> Message
- Sound.SC3.Server.Command.Plain: n_run :: [(Int, Bool)] -> Message
+ Sound.SC3.Server.Command.Plain: n_run :: [(Node_Id, Bool)] -> Message
- Sound.SC3.Server.Command.Plain: n_set :: Int -> [(String, Double)] -> Message
+ Sound.SC3.Server.Command.Plain: n_set :: Node_Id -> [(String, Double)] -> Message
- Sound.SC3.Server.Command.Plain: n_set1 :: Int -> String -> Double -> Message
+ Sound.SC3.Server.Command.Plain: n_set1 :: Node_Id -> String -> Double -> Message
- Sound.SC3.Server.Command.Plain: n_setn :: Int -> [(String, [Double])] -> Message
+ Sound.SC3.Server.Command.Plain: n_setn :: Node_Id -> [(String, [Double])] -> Message
- Sound.SC3.Server.Command.Plain: n_trace :: [Int] -> Message
+ Sound.SC3.Server.Command.Plain: n_trace :: [Node_Id] -> Message
- Sound.SC3.Server.Command.Plain: p_new :: [(Int, AddAction, Int)] -> Message
+ Sound.SC3.Server.Command.Plain: p_new :: [(Group_Id, AddAction, Node_Id)] -> Message
- Sound.SC3.Server.Command.Plain: s_get :: Int -> [String] -> Message
+ Sound.SC3.Server.Command.Plain: s_get :: Synth_Id -> [String] -> Message
- Sound.SC3.Server.Command.Plain: s_getn :: Int -> [(String, Int)] -> Message
+ Sound.SC3.Server.Command.Plain: s_getn :: Synth_Id -> [(String, Int)] -> Message
- Sound.SC3.Server.Command.Plain: s_new :: String -> Int -> AddAction -> Int -> [(String, Double)] -> Message
+ Sound.SC3.Server.Command.Plain: s_new :: String -> Synth_Id -> AddAction -> Node_Id -> [(String, Double)] -> Message
- Sound.SC3.Server.Command.Plain: s_new0 :: String -> Int -> AddAction -> Int -> Message
+ Sound.SC3.Server.Command.Plain: s_new0 :: String -> Synth_Id -> AddAction -> Node_Id -> Message
- Sound.SC3.Server.Command.Plain: s_noid :: [Int] -> Message
+ Sound.SC3.Server.Command.Plain: s_noid :: [Synth_Id] -> Message
- Sound.SC3.Server.Graphdef: read_control :: Handle -> IO Control
+ Sound.SC3.Server.Graphdef: read_control :: (Handle -> IO Int) -> Handle -> IO Control
- Sound.SC3.Server.Graphdef: read_input :: Handle -> IO Input
+ Sound.SC3.Server.Graphdef: read_input :: (Handle -> IO Int) -> Handle -> IO Input
- Sound.SC3.Server.Graphdef: read_ugen :: Handle -> IO UGen
+ Sound.SC3.Server.Graphdef: read_ugen :: (Handle -> IO Int) -> Handle -> IO UGen
- Sound.SC3.Server.NRT: type NRT_Render_Plain = (FilePath, FilePath, Int, Int, SampleFormat)
+ Sound.SC3.Server.NRT: type NRT_Render_Plain = (FilePath, FilePath, Int, Int, SampleFormat, [String])
- Sound.SC3.Server.Recorder: rec_synthdef :: SC3_Recorder -> Synthdef
+ Sound.SC3.Server.Recorder: rec_synthdef :: Int -> Synthdef
- Sound.SC3.Server.Synthdef: graph_stat :: Graph -> String
+ Sound.SC3.Server.Synthdef: graph_stat :: Graph -> [String]
- Sound.SC3.Server.Transport.FD: b_fetch :: Transport t => t -> Int -> Int -> IO [Double]
+ Sound.SC3.Server.Transport.FD: b_fetch :: Transport t => t -> Int -> Int -> IO [[Double]]
- Sound.SC3.Server.Transport.Monad: audition_at :: Audible e => (Int, AddAction, Int) -> e -> IO ()
+ Sound.SC3.Server.Transport.Monad: audition_at :: Audible e => Play_Opt -> e -> IO ()
- Sound.SC3.Server.Transport.Monad: b_fetch :: DuplexOSC m => Int -> Int -> m [Double]
+ Sound.SC3.Server.Transport.Monad: b_fetch :: DuplexOSC m => Int -> Int -> m [[Double]]
- Sound.SC3.Server.Transport.Monad: class Audible e where play = play_at (- 1, AddToHead, 1)
+ Sound.SC3.Server.Transport.Monad: class Audible e where play = play_at (- 1, AddToHead, 1, [])
- Sound.SC3.Server.Transport.Monad: playGraphdef :: DuplexOSC m => (Int, AddAction, Int) -> Graphdef -> m ()
+ Sound.SC3.Server.Transport.Monad: playGraphdef :: DuplexOSC m => Play_Opt -> Graphdef -> m ()
- Sound.SC3.Server.Transport.Monad: playSynthdef :: DuplexOSC m => (Int, AddAction, Int) -> Synthdef -> m ()
+ Sound.SC3.Server.Transport.Monad: playSynthdef :: DuplexOSC m => Play_Opt -> Synthdef -> m ()
- Sound.SC3.Server.Transport.Monad: playUGen :: DuplexOSC m => (Int, AddAction, Int) -> UGen -> m ()
+ Sound.SC3.Server.Transport.Monad: playUGen :: DuplexOSC m => Play_Opt -> UGen -> m ()
- Sound.SC3.Server.Transport.Monad: play_at :: (Audible e, Transport m) => (Int, AddAction, Int) -> e -> m ()
+ Sound.SC3.Server.Transport.Monad: play_at :: (Audible e, Transport m) => Play_Opt -> e -> m ()
- Sound.SC3.UGen.Bindings.Composite: dconsM :: UId m => UGen -> UGen -> m UGen
+ Sound.SC3.UGen.Bindings.Composite: dconsM :: (UId m) => UGen -> UGen -> m UGen
- Sound.SC3.UGen.Bindings.Composite: tChooseM :: UId m => UGen -> UGen -> m UGen
+ Sound.SC3.UGen.Bindings.Composite: tChooseM :: (UId m) => UGen -> UGen -> m UGen
- Sound.SC3.UGen.Bindings.Composite: tWChooseM :: UId m => UGen -> UGen -> UGen -> UGen -> m UGen
+ Sound.SC3.UGen.Bindings.Composite: tWChooseM :: (UId m) => UGen -> UGen -> UGen -> UGen -> m UGen
- Sound.SC3.UGen.Bindings.DB: balance2 :: Rate -> UGen -> UGen -> UGen -> UGen -> UGen
+ Sound.SC3.UGen.Bindings.DB: balance2 :: UGen -> UGen -> UGen -> UGen -> UGen
- Sound.SC3.UGen.Bindings.DB: bufAllpassC :: Rate -> UGen -> UGen -> UGen -> UGen -> UGen
+ Sound.SC3.UGen.Bindings.DB: bufAllpassC :: UGen -> UGen -> UGen -> UGen -> UGen
- Sound.SC3.UGen.Bindings.DB: bufAllpassL :: Rate -> UGen -> UGen -> UGen -> UGen -> UGen
+ Sound.SC3.UGen.Bindings.DB: bufAllpassL :: UGen -> UGen -> UGen -> UGen -> UGen
- Sound.SC3.UGen.Bindings.DB: bufAllpassN :: Rate -> UGen -> UGen -> UGen -> UGen -> UGen
+ Sound.SC3.UGen.Bindings.DB: bufAllpassN :: UGen -> UGen -> UGen -> UGen -> UGen
- Sound.SC3.UGen.Bindings.DB: bufCombC :: Rate -> UGen -> UGen -> UGen -> UGen -> UGen
+ Sound.SC3.UGen.Bindings.DB: bufCombC :: UGen -> UGen -> UGen -> UGen -> UGen
- Sound.SC3.UGen.Bindings.DB: bufCombL :: Rate -> UGen -> UGen -> UGen -> UGen -> UGen
+ Sound.SC3.UGen.Bindings.DB: bufCombL :: UGen -> UGen -> UGen -> UGen -> UGen
- Sound.SC3.UGen.Bindings.DB: bufCombN :: Rate -> UGen -> UGen -> UGen -> UGen -> UGen
+ Sound.SC3.UGen.Bindings.DB: bufCombN :: UGen -> UGen -> UGen -> UGen -> UGen
- Sound.SC3.UGen.Bindings.DB: bufDelayC :: Rate -> UGen -> UGen -> UGen -> UGen
+ Sound.SC3.UGen.Bindings.DB: bufDelayC :: UGen -> UGen -> UGen -> UGen
- Sound.SC3.UGen.Bindings.DB: bufDelayL :: Rate -> UGen -> UGen -> UGen -> UGen
+ Sound.SC3.UGen.Bindings.DB: bufDelayL :: UGen -> UGen -> UGen -> UGen
- Sound.SC3.UGen.Bindings.DB: bufDelayN :: Rate -> UGen -> UGen -> UGen -> UGen
+ Sound.SC3.UGen.Bindings.DB: bufDelayN :: UGen -> UGen -> UGen -> UGen
- Sound.SC3.UGen.Bindings.DB: done :: Rate -> UGen -> UGen
+ Sound.SC3.UGen.Bindings.DB: done :: UGen -> UGen
- Sound.SC3.UGen.Bindings.DB: freeSelfWhenDone :: Rate -> UGen -> UGen
+ Sound.SC3.UGen.Bindings.DB: freeSelfWhenDone :: UGen -> UGen
- Sound.SC3.UGen.Bindings.DB: inTrig :: Int -> Rate -> UGen -> UGen
+ Sound.SC3.UGen.Bindings.DB: inTrig :: Int -> UGen -> UGen
- Sound.SC3.UGen.Bindings.DB: indexInBetween :: Rate -> UGen -> UGen -> UGen
+ Sound.SC3.UGen.Bindings.DB: indexInBetween :: UGen -> UGen -> UGen
- Sound.SC3.UGen.Bindings.DB: loudness :: Rate -> UGen -> UGen -> UGen -> UGen
+ Sound.SC3.UGen.Bindings.DB: loudness :: UGen -> UGen -> UGen -> UGen
- Sound.SC3.UGen.Bindings.DB: pause :: Rate -> UGen -> UGen -> UGen
+ Sound.SC3.UGen.Bindings.DB: pause :: UGen -> UGen -> UGen
- Sound.SC3.UGen.Bindings.DB: pauseSelf :: Rate -> UGen -> UGen
+ Sound.SC3.UGen.Bindings.DB: pauseSelf :: UGen -> UGen
- Sound.SC3.UGen.Bindings.DB: pauseSelfWhenDone :: Rate -> UGen -> UGen
+ Sound.SC3.UGen.Bindings.DB: pauseSelfWhenDone :: UGen -> UGen
- Sound.SC3.UGen.Bindings.DB: pv_HainsworthFoote :: UGen -> UGen
+ Sound.SC3.UGen.Bindings.DB: pv_HainsworthFoote :: UGen -> UGen -> UGen -> UGen -> UGen -> UGen
- Sound.SC3.UGen.Bindings.DB: pv_JensenAndersen :: UGen -> UGen
+ Sound.SC3.UGen.Bindings.DB: pv_JensenAndersen :: UGen -> UGen -> UGen -> UGen -> UGen -> UGen -> UGen -> UGen
- Sound.SC3.UGen.Bindings.DB: schmidt :: Rate -> UGen -> UGen -> UGen -> UGen
+ Sound.SC3.UGen.Bindings.DB: schmidt :: UGen -> UGen -> UGen -> UGen
- Sound.SC3.UGen.Bindings.DB: varLag :: Rate -> UGen -> UGen -> UGen -> UGen -> UGen -> UGen
+ Sound.SC3.UGen.Bindings.DB: varLag :: UGen -> UGen -> UGen -> UGen -> UGen -> UGen
- Sound.SC3.UGen.Bindings.Monad: brownNoiseM :: UId m => Rate -> m UGen
+ Sound.SC3.UGen.Bindings.Monad: brownNoiseM :: (UId m) => Rate -> m UGen
- Sound.SC3.UGen.Bindings.Monad: clipNoiseM :: UId m => Rate -> m UGen
+ Sound.SC3.UGen.Bindings.Monad: clipNoiseM :: (UId m) => Rate -> m UGen
- Sound.SC3.UGen.Bindings.Monad: coinGateM :: UId m => UGen -> UGen -> m UGen
+ Sound.SC3.UGen.Bindings.Monad: coinGateM :: (UId m) => UGen -> UGen -> m UGen
- Sound.SC3.UGen.Bindings.Monad: dbrownM :: UId m => UGen -> UGen -> UGen -> UGen -> m UGen
+ Sound.SC3.UGen.Bindings.Monad: dbrownM :: (UId m) => UGen -> UGen -> UGen -> UGen -> m UGen
- Sound.SC3.UGen.Bindings.Monad: dbufrdM :: UId m => UGen -> UGen -> Loop -> m UGen
+ Sound.SC3.UGen.Bindings.Monad: dbufrdM :: (UId m) => UGen -> UGen -> Loop -> m UGen
- Sound.SC3.UGen.Bindings.Monad: dbufwrM :: UId m => UGen -> UGen -> UGen -> Loop -> m UGen
+ Sound.SC3.UGen.Bindings.Monad: dbufwrM :: (UId m) => UGen -> UGen -> UGen -> Loop -> m UGen
- Sound.SC3.UGen.Bindings.Monad: dgeomM :: UId m => UGen -> UGen -> UGen -> m UGen
+ Sound.SC3.UGen.Bindings.Monad: dgeomM :: (UId m) => UGen -> UGen -> UGen -> m UGen
- Sound.SC3.UGen.Bindings.Monad: dibrownM :: UId m => UGen -> UGen -> UGen -> UGen -> m UGen
+ Sound.SC3.UGen.Bindings.Monad: dibrownM :: (UId m) => UGen -> UGen -> UGen -> UGen -> m UGen
- Sound.SC3.UGen.Bindings.Monad: diwhiteM :: UId m => UGen -> UGen -> UGen -> m UGen
+ Sound.SC3.UGen.Bindings.Monad: diwhiteM :: (UId m) => UGen -> UGen -> UGen -> m UGen
- Sound.SC3.UGen.Bindings.Monad: drandM :: UId m => UGen -> UGen -> m UGen
+ Sound.SC3.UGen.Bindings.Monad: drandM :: (UId m) => UGen -> UGen -> m UGen
- Sound.SC3.UGen.Bindings.Monad: dseqM :: UId m => UGen -> UGen -> m UGen
+ Sound.SC3.UGen.Bindings.Monad: dseqM :: (UId m) => UGen -> UGen -> m UGen
- Sound.SC3.UGen.Bindings.Monad: dserM :: UId m => UGen -> UGen -> m UGen
+ Sound.SC3.UGen.Bindings.Monad: dserM :: (UId m) => UGen -> UGen -> m UGen
- Sound.SC3.UGen.Bindings.Monad: dseriesM :: UId m => UGen -> UGen -> UGen -> m UGen
+ Sound.SC3.UGen.Bindings.Monad: dseriesM :: (UId m) => UGen -> UGen -> UGen -> m UGen
- Sound.SC3.UGen.Bindings.Monad: dshufM :: UId m => UGen -> UGen -> m UGen
+ Sound.SC3.UGen.Bindings.Monad: dshufM :: (UId m) => UGen -> UGen -> m UGen
- Sound.SC3.UGen.Bindings.Monad: dstutterM :: UId m => UGen -> UGen -> m UGen
+ Sound.SC3.UGen.Bindings.Monad: dstutterM :: (UId m) => UGen -> UGen -> m UGen
- Sound.SC3.UGen.Bindings.Monad: dswitch1M :: UId m => UGen -> UGen -> m UGen
+ Sound.SC3.UGen.Bindings.Monad: dswitch1M :: (UId m) => UGen -> UGen -> m UGen
- Sound.SC3.UGen.Bindings.Monad: dswitchM :: UId m => UGen -> UGen -> m UGen
+ Sound.SC3.UGen.Bindings.Monad: dswitchM :: (UId m) => UGen -> UGen -> m UGen
- Sound.SC3.UGen.Bindings.Monad: dust2M :: UId m => Rate -> UGen -> m UGen
+ Sound.SC3.UGen.Bindings.Monad: dust2M :: (UId m) => Rate -> UGen -> m UGen
- Sound.SC3.UGen.Bindings.Monad: dustM :: UId m => Rate -> UGen -> m UGen
+ Sound.SC3.UGen.Bindings.Monad: dustM :: (UId m) => Rate -> UGen -> m UGen
- Sound.SC3.UGen.Bindings.Monad: dwhiteM :: UId m => UGen -> UGen -> UGen -> m UGen
+ Sound.SC3.UGen.Bindings.Monad: dwhiteM :: (UId m) => UGen -> UGen -> UGen -> m UGen
- Sound.SC3.UGen.Bindings.Monad: dwrandM :: UId m => UGen -> UGen -> UGen -> m UGen
+ Sound.SC3.UGen.Bindings.Monad: dwrandM :: (UId m) => UGen -> UGen -> UGen -> m UGen
- Sound.SC3.UGen.Bindings.Monad: dxrandM :: UId m => UGen -> UGen -> m UGen
+ Sound.SC3.UGen.Bindings.Monad: dxrandM :: (UId m) => UGen -> UGen -> m UGen
- Sound.SC3.UGen.Bindings.Monad: expRandM :: UId m => UGen -> UGen -> m UGen
+ Sound.SC3.UGen.Bindings.Monad: expRandM :: (UId m) => UGen -> UGen -> m UGen
- Sound.SC3.UGen.Bindings.Monad: grayNoiseM :: UId m => Rate -> m UGen
+ Sound.SC3.UGen.Bindings.Monad: grayNoiseM :: (UId m) => Rate -> m UGen
- Sound.SC3.UGen.Bindings.Monad: iRandM :: UId m => UGen -> UGen -> m UGen
+ Sound.SC3.UGen.Bindings.Monad: iRandM :: (UId m) => UGen -> UGen -> m UGen
- Sound.SC3.UGen.Bindings.Monad: lfClipNoiseM :: UId m => Rate -> UGen -> m UGen
+ Sound.SC3.UGen.Bindings.Monad: lfClipNoiseM :: (UId m) => Rate -> UGen -> m UGen
- Sound.SC3.UGen.Bindings.Monad: lfNoise0M :: UId m => Rate -> UGen -> m UGen
+ Sound.SC3.UGen.Bindings.Monad: lfNoise0M :: (UId m) => Rate -> UGen -> m UGen
- Sound.SC3.UGen.Bindings.Monad: lfNoise1M :: UId m => Rate -> UGen -> m UGen
+ Sound.SC3.UGen.Bindings.Monad: lfNoise1M :: (UId m) => Rate -> UGen -> m UGen
- Sound.SC3.UGen.Bindings.Monad: lfNoise2M :: UId m => Rate -> UGen -> m UGen
+ Sound.SC3.UGen.Bindings.Monad: lfNoise2M :: (UId m) => Rate -> UGen -> m UGen
- Sound.SC3.UGen.Bindings.Monad: lfdClipNoiseM :: UId m => Rate -> UGen -> m UGen
+ Sound.SC3.UGen.Bindings.Monad: lfdClipNoiseM :: (UId m) => Rate -> UGen -> m UGen
- Sound.SC3.UGen.Bindings.Monad: lfdNoise0M :: UId m => Rate -> UGen -> m UGen
+ Sound.SC3.UGen.Bindings.Monad: lfdNoise0M :: (UId m) => Rate -> UGen -> m UGen
- Sound.SC3.UGen.Bindings.Monad: lfdNoise1M :: UId m => Rate -> UGen -> m UGen
+ Sound.SC3.UGen.Bindings.Monad: lfdNoise1M :: (UId m) => Rate -> UGen -> m UGen
- Sound.SC3.UGen.Bindings.Monad: lfdNoise3M :: UId m => Rate -> UGen -> m UGen
+ Sound.SC3.UGen.Bindings.Monad: lfdNoise3M :: (UId m) => Rate -> UGen -> m UGen
- Sound.SC3.UGen.Bindings.Monad: linRandM :: UId m => UGen -> UGen -> UGen -> m UGen
+ Sound.SC3.UGen.Bindings.Monad: linRandM :: (UId m) => UGen -> UGen -> UGen -> m UGen
- Sound.SC3.UGen.Bindings.Monad: nRandM :: UId m => UGen -> UGen -> UGen -> m UGen
+ Sound.SC3.UGen.Bindings.Monad: nRandM :: (UId m) => UGen -> UGen -> UGen -> m UGen
- Sound.SC3.UGen.Bindings.Monad: pinkNoiseM :: UId m => Rate -> m UGen
+ Sound.SC3.UGen.Bindings.Monad: pinkNoiseM :: (UId m) => Rate -> m UGen
- Sound.SC3.UGen.Bindings.Monad: pv_BinScrambleM :: UId m => UGen -> UGen -> UGen -> UGen -> m UGen
+ Sound.SC3.UGen.Bindings.Monad: pv_BinScrambleM :: (UId m) => UGen -> UGen -> UGen -> UGen -> m UGen
- Sound.SC3.UGen.Bindings.Monad: pv_RandCombM :: UId m => UGen -> UGen -> UGen -> m UGen
+ Sound.SC3.UGen.Bindings.Monad: pv_RandCombM :: (UId m) => UGen -> UGen -> UGen -> m UGen
- Sound.SC3.UGen.Bindings.Monad: pv_RandWipeM :: UId m => UGen -> UGen -> UGen -> UGen -> m UGen
+ Sound.SC3.UGen.Bindings.Monad: pv_RandWipeM :: (UId m) => UGen -> UGen -> UGen -> UGen -> m UGen
- Sound.SC3.UGen.Bindings.Monad: randM :: UId m => UGen -> UGen -> m UGen
+ Sound.SC3.UGen.Bindings.Monad: randM :: (UId m) => UGen -> UGen -> m UGen
- Sound.SC3.UGen.Bindings.Monad: tExpRandM :: UId m => UGen -> UGen -> UGen -> m UGen
+ Sound.SC3.UGen.Bindings.Monad: tExpRandM :: (UId m) => UGen -> UGen -> UGen -> m UGen
- Sound.SC3.UGen.Bindings.Monad: tIRandM :: UId m => UGen -> UGen -> UGen -> m UGen
+ Sound.SC3.UGen.Bindings.Monad: tIRandM :: (UId m) => UGen -> UGen -> UGen -> m UGen
- Sound.SC3.UGen.Bindings.Monad: tRandM :: UId m => UGen -> UGen -> UGen -> m UGen
+ Sound.SC3.UGen.Bindings.Monad: tRandM :: (UId m) => UGen -> UGen -> UGen -> m UGen
- Sound.SC3.UGen.Bindings.Monad: tWindexM :: UId m => UGen -> UGen -> UGen -> m UGen
+ Sound.SC3.UGen.Bindings.Monad: tWindexM :: (UId m) => UGen -> UGen -> UGen -> m UGen
- Sound.SC3.UGen.Bindings.Monad: whiteNoiseM :: UId m => Rate -> m UGen
+ Sound.SC3.UGen.Bindings.Monad: whiteNoiseM :: (UId m) => Rate -> m UGen
- Sound.SC3.UGen.Enum: Loop :: Loop
+ Sound.SC3.UGen.Enum: Loop :: Loop' t
- Sound.SC3.UGen.Enum: NoLoop :: Loop
+ Sound.SC3.UGen.Enum: NoLoop :: Loop' t
- Sound.SC3.UGen.Enum: WithLoop :: UGen -> Loop
+ Sound.SC3.UGen.Enum: WithLoop :: t -> Loop' t
- Sound.SC3.UGen.Enum: from_loop :: Loop -> UGen
+ Sound.SC3.UGen.Enum: from_loop :: Num t => Loop' t -> t
- Sound.SC3.UGen.Graph.Reconstruct: reconstruct_graph_str :: Graph -> String
+ Sound.SC3.UGen.Graph.Reconstruct: reconstruct_graph_str :: String -> Graph -> String
- Sound.SC3.UGen.Math: binop_hs_tbl :: (Real n, Floating n, RealFrac n, Ord n) => [(Binary, n -> n -> n)]
+ Sound.SC3.UGen.Math: binop_hs_tbl :: (Real n, Floating n, RealFrac n) => [(Binary, n -> n -> n)]
- Sound.SC3.UGen.Math: binop_special_hs :: (Real n, RealFrac n, Floating n, Ord n) => Int -> Maybe (n -> n -> n)
+ Sound.SC3.UGen.Math: binop_special_hs :: (RealFrac n, Floating n) => Int -> Maybe (n -> n -> n)
- Sound.SC3.UGen.Math: class (Floating a, RealFrac a, Ord a) => BinaryOp a where absDif a b = abs (a - b) amClip a b = if b <= 0 then 0 else a * b atan2E a b = atan (b / a) clip2 a b = clip_ a (- b) b difSqr = difSqr' excess a b = a - clip_ a (- b) b exprandRange = error "exprandRange" fill = error "fill" firstArg a _ = a fold2 a b = fold_ a (- b) b gcdE = error "gcdE" hypot x y = sqrt (x * x + y * y) hypotx = hypotx' iDiv = sc3_idiv lcmE = error "lcmE" modE = error "modE" randRange = error "randRange" ring1 a b = a * b + a ring2 a b = a * b + a + b ring3 a b = a * a * b ring4 a b = a * a * b - a * b * b roundUp = error "roundUp" scaleNeg a b = (abs a - a) * b' + a where b' = 0.5 * b + 0.5 sqrDif a b = (a - b) * (a - b) sqrSum a b = (a + b) * (a + b) sumSqr a b = (a * a) + (b * b) thresh a b = if a < b then 0 else a trunc = error "trunc" wrap2 = error "wrap2"
+ Sound.SC3.UGen.Math: class (Floating a, RealFrac a, Ord a) => BinaryOp a where absDif a b = abs (a - b) amClip a b = if b <= 0 then 0 else a * b atan2E a b = atan (b / a) clip2 a b = sc_clip a (- b) b difSqr = sc_dif_sqr excess a b = a - sc_clip a (- b) b exprandRange = error "exprandRange" fill = error "fill" firstArg a _ = a fold2 a b = fold_ a (- b) b gcdE = error "gcdE" hypot = sc_hypot hypotx = sc_hypotx iDiv = sc3_idiv lcmE = error "lcmE" modE = error "modE" randRange = error "randRange" ring1 a b = a * b + a ring2 a b = a * b + a + b ring3 a b = a * a * b ring4 a b = a * a * b - a * b * b roundUp = error "roundUp" scaleNeg a b = (abs a - a) * b' + a where b' = 0.5 * b + 0.5 sqrDif a b = (a - b) * (a - b) sqrSum a b = (a + b) * (a + b) sumSqr a b = (a * a) + (b * b) thresh a b = if a < b then 0 else a trunc = error "trunc" wrap2 = error "wrap2"
- Sound.SC3.UGen.Math: class RealFrac a => RealFracE a where properFractionE = sc3_properFraction truncateE = sc3_truncate roundE = sc3_round ceilingE = sc3_ceiling floorE = sc3_floor
+ Sound.SC3.UGen.Math: class RealFrac a => RealFracE a where properFractionE = sc3_properFraction truncateE = sc_truncate roundE = sc_round ceilingE = sc_ceiling floorE = sc_floor
- Sound.SC3.UGen.Math: class (Floating a, Ord a) => UnaryOp a where ampDb = ampDb' asFloat = error "asFloat" asInt = error "asInt" cpsMIDI = cpsMIDI' cpsOct = cpsOct' cubed = cubed' dbAmp = dbAmp' distort = error "distort" frac = error "frac" isNil a = if a == 0.0 then 0.0 else 1.0 log10 = logBase 10 log2 = logBase 2 midiCPS = midiCPS' midiRatio = midiRatio' notE a = if a > 0.0 then 0.0 else 1.0 notNil a = if a /= 0.0 then 0.0 else 1.0 octCPS = octCPS' ramp_ _ = error "ramp_" ratioMIDI = ratioMIDI' softClip = error "softClip" squared = squared'
+ Sound.SC3.UGen.Math: class (Floating a, Ord a) => UnaryOp a where ampDb = amp_to_db asFloat = error "asFloat" asInt = error "asInt" cpsMIDI = cps_to_midi cpsOct = cps_to_oct cubed n = n * n * n dbAmp = db_to_amp distort = error "distort" frac = error "frac" isNil a = if a == 0.0 then 0.0 else 1.0 log10 = logBase 10 log2 = logBase 2 midiCPS = midi_to_cps midiRatio = midi_to_ratio notE a = if a > 0.0 then 0.0 else 1.0 notNil a = if a /= 0.0 then 0.0 else 1.0 octCPS = oct_to_cps ramp_ _ = error "ramp_" ratioMIDI = ratio_to_midi softClip = error "softClip" squared = \ z -> z * z
- Sound.SC3.UGen.Math: mul_add :: TernaryOp a => a -> a -> a -> a
+ Sound.SC3.UGen.Math: mul_add :: MulAdd a => a -> a -> a -> a
- Sound.SC3.UGen.Math: uop_hs_tbl :: (RealFrac n, Floating n, Ord n) => [(Unary, n -> n)]
+ Sound.SC3.UGen.Math: uop_hs_tbl :: (RealFrac n, Floating n) => [(Unary, n -> n)]
- Sound.SC3.UGen.Math: uop_special_hs :: (RealFrac n, Floating n, Ord n) => Int -> Maybe (n -> n)
+ Sound.SC3.UGen.Math: uop_special_hs :: (RealFrac n, Floating n) => Int -> Maybe (n -> n)
- Sound.SC3.UGen.Type: mceDegree :: UGen -> Int
+ Sound.SC3.UGen.Type: mceDegree :: UGen -> Maybe Int
- Sound.SC3.UGen.UGen: meta_control :: Rate -> String -> Double -> C_Meta' Double -> UGen
+ Sound.SC3.UGen.UGen: meta_control :: Rate -> String -> Double -> C_Meta_T5 Double -> UGen
- Sound.SC3.UGen.UId: class (Functor m, Applicative m, MonadIO m) => UId m where generateUId = fmap hashUnique (liftIO newUnique)
+ Sound.SC3.UGen.UId: class (Functor m, Applicative m, Monad m) => UId m
- Sound.SC3.UGen.UId: clone :: UId m => Int -> m UGen -> m UGen
+ Sound.SC3.UGen.UId: clone :: (UId m) => Int -> m UGen -> m UGen

This diff is very large; some files are shown as “too large to diff”. Download the raw patch for the complete diff.

Files

Help/Server/b_alloc.help.lhs view
@@ -1,11 +1,18 @@-> Sound.SC3.Server.Help.viewServerHelp "/b_alloc"+    Sound.SC3.Server.Help.viewServerHelp "/b_alloc"  Buffer indices are not restricted by the number of available buffers-at the server.  Below allocates a buffer at index 8192.+at the server.  Below allocates a buffer at index 2 ^ 15. -> withSC3 (async (b_alloc_setn1 8192 0 [0,3,7,10]))+> import Sound.SC3 {- hsc3 -} -> let {x = mouseX KR 0 9 Linear 0.1->     ;k = degreeToKey 8192 x 12->     ;o = sinOsc AR (midiCPS (48 + k)) 0 * 0.1}-> in audition (out 0 o)+> b0 :: Num n => n+> b0 = 2 ^ 15++> m0 = b_alloc_setn1 b0 0 [0,3,7,10]++    withSC3 (async m0)++> g0 =+>     let x = mouseX KR 0 9 Linear 0.1+>         k = degreeToKey b0 x 12+>     in sinOsc AR (midiCPS (48 + k)) 0 * 0.1
Help/Server/b_allocRead.help.lhs view
@@ -1,12 +1,14 @@-> Sound.SC3.Server.Help.viewServerHelp "/b_allocRead"+    Sound.SC3.Server.Help.viewServerHelp "/b_allocRead" -> import Sound.SC3+> import Sound.OSC {- hosc -}+> import Sound.SC3 {- hsc3 -}  Read a large audio file into a buffer. -> let fn = "/home/rohan/data/audio/xenakis/jonchaies.wav"-> in withSC3 (async (b_allocRead 0 fn 0 0))+> fn = "/home/rohan/data/audio/xenakis/jonchaies.wav" +    withSC3 (async (b_allocRead 0 fn 0 0))+ Audio data is loaded in IEEE 32-bit form, so in-memory storage can be greater than on-disk storage. @@ -18,27 +20,32 @@ 162M    data/audio/xenakis/jonchaies.wav $ -> round ((16 * 60 * 44100 * 4 * 2) / (1024 * 1024)) == 323-> round ((42271320 * 2 * 4) / (1024 * 1024)) == 323+    round ((16 * 60 * 44100 * 4 * 2) / (1024 * 1024)) == 323+    round ((42271320 * 2 * 4) / (1024 * 1024)) == 323  Query buffer. -> withSC3 (do {send (b_query [0])->             ;r <- waitReply "/b_info"->             ;liftIO (print r)})+> q0 :: Connection UDP ()+> q0 = do+>      sendMessage (b_query [0])+>      r <- waitReply "/b_info"+>      liftIO (print r) +    withSC3 q0+ Play buffer. -> let {n = 257; s = bufRateScale KR n}-> in audition (out 0 (playBuf 1 AR n s 1 0 NoLoop RemoveSynth))+> g0 =+>     let n = 257+>         s = bufRateScale KR n+>     in playBuf 1 AR n s 1 0 NoLoop RemoveSynth  Re-read file into buffer with the same identifier.  The existing buffer is freed but not before further memory is allocated, intermediate in-memory use is greater than final memory use. -> let fn = "/home/rohan/data/audio/xenakis/jonchaies.wav"-> in withSC3 (async (b_allocRead 0 fn 0 0))+    withSC3 (async (b_allocRead 0 fn 0 0))  Free buffer.  Memory is immediately made free. -> withSC3 (async (b_free 0))+    withSC3 (async (b_free 0))
Help/Server/b_allocReadChannel.help.lhs view
@@ -1,1 +1,29 @@ > Sound.SC3.Server.Help.viewServerHelp "/b_allocReadChannel"++> import Sound.SC3++Read an audio file with many channels (here 2000)++> let fn = "/home/rohan/sw/hsc3-sf/au/mc-12-2000.au"++> withSC3 (async (b_allocRead 0 fn 0 0))++Query buffer++> withSC3 (b_query1_unpack 0)++Read only specified channels++> withSC3 (async (b_allocReadChannel 0 fn 0 0 [0..1023]))++Query buffer++> withSC3 (b_query1_unpack 0)++Examine buffer++> import Data.List {- base -}+> import Data.List.Split {- split -}+> let (nf,nc) = (12,1024)+> d <- withSC3 (b_getn1_data_segment 128 0 (0,nf * nc))+> (putStrLn . unlines . transpose . chunksOf nc . map (\n -> if n > 0 then '1' else '0')) d
Help/Server/b_free.help.lhs view
@@ -1,9 +1,11 @@-> Sound.SC3.Server.Help.viewServerHelp "/b_free"+    Sound.SC3.Server.Help.viewServerHelp "/b_free" +> import Sound.SC3 {- hsc3 -}+ It is safe to free un-allocated buffers. -> withSC3 (async (b_free (2 ^ 15)))+    withSC3 (async (b_free (2 ^ 15)))  There is no multiple buffer form. -> withSC3 (mapM_ (\k -> async (b_free k)) [0..256])+    withSC3 (mapM_ (\k -> async (b_free k)) [0..256])
Help/Server/b_query.help.lhs view
@@ -15,6 +15,12 @@ >             ;r <- waitReply "/b_info" >             ;liftIO (print r)}) +Variant that unpacks the result.++Query is of (buffer-id/int,#-frames/int,#-channels/int,sample-rate/float).++> withSC3 (b_query1_unpack 0)+ Play buffer  > audition (out 0 (osc AR 0 220 0 * 0.1))
Help/Server/c_get.help.lhs view
@@ -1,7 +1,7 @@ > Sound.SC3.Server.Help.viewServerHelp "/c_get"  > import Sound.OSC {- hosc -}-> import Sound.SC3.ID {- hsc3 -}+> import Sound.SC3 {- hsc3 -}  > audition (out 0 (tRand 'α' 220 2200 (dust 'β' KR 1))) 
Help/Server/dumpOSC.help.lhs view
@@ -1,8 +1,15 @@-> Sound.SC3.Server.Help.viewServerHelp "/dumpOSC"+    Sound.SC3.Server.Help.viewServerHelp "/dumpOSC" -> import Sound.SC3.ID+> import Sound.OSC {- hosc -}+> import Sound.SC3 {- hsc3 -} -> withSC3 (send (dumpOSC TextPrinter))-> audition (out 0 (sinOsc AR (rand 'α' 440 880) 0 * 0.1))-> withSC3 reset-> withSC3 (send (dumpOSC NoPrinter))+> ex_01 :: Transport m => m ()+> ex_01 = do+>   sendMessage (dumpOSC TextPrinter)+>   play (out 0 (sinOsc AR (rand 'α' 440 880) 0 * 0.1))+>   pauseThread 1.0+>   reset+>   sendMessage (dumpOSC NoPrinter)++    withSC3 ex_01+    withSC3 (sendMessage (dumpOSC TextPrinter))
Help/Server/g_freeAll.help.lhs view
@@ -1,1 +1,8 @@-> Sound.SC3.Server.Help.viewServerHelp "/g_freeAll"+    > Sound.SC3.Server.Help.viewServerHelp "/g_freeAll"++> import Sound.OSC+> import Sound.SC3++> m1 = g_freeAll [0]++     > withSC3 (sendMessage m1)
Help/Server/g_queryTree.help.lhs view
@@ -1,28 +1,27 @@-> Sound.SC3.Server.Help.viewServerHelp "/g_queryTree"+    > Sound.SC3.Server.Help.viewServerHelp "/g_queryTree"  > import Sound.OSC {- hosc -} > import Sound.SC3 {- hsc3 -}+> import qualified Data.Tree as T {- containers -} -> let d = let {f = control KR "freq" 440->             ;o = saw AR f * 0.05}->         in synthdef "saw" (out 0 o)+> d_0 =+>     let f = control KR "freq" 440+>         o = saw AR f * 0.05+>     in synthdef "saw" (out 0 o) -> withSC3 (async (d_recv d) >>->          send (g_new [(100,AddToTail,1)]) >>->          send (s_new0 "saw" 1000 AddToTail 100))+> m_0 = [d_recv d_0,g_new [(100,AddToTail,1)],s_new0 "saw" 1000 AddToTail 100] -> r <- withSC3 (send (g_queryTree [(0,True)]) >>->               waitReply "/g_queryTree.reply")+    > withSC3 (mapM_ maybe_async m_0) -> print r+> run_query_tree = withSC3 (g_queryTree1_unpack 0) -> withSC3 (send (g_dumpTree [(0,True)]))+    > qt <- run_query_tree+    > print qt+    > withSC3 (sendMessage (g_dumpTree [(0,True)]))+    > queryNode_to_group_seq qt -There is support for extracting the node tree into standard haskell+There is support for extracting the node tree into the standard haskell tree data type. -> import qualified Data.Tree as T {- containers -}--> let tr = queryTree_rt (queryTree (messageDatum r))--> putStrLn (unlines ["::TREE::",T.drawTree (fmap query_node_pp tr)])+    > r_tr = queryTree_rt qt+    > putStrLn (unlines ["::TREE::",T.drawTree (fmap query_node_pp r_tr)])
Help/Server/n_query.help.lhs view
@@ -1,16 +1,14 @@ > Sound.SC3.Server.Help.viewServerHelp "/n_query" -> import Sound.OSC-> import Sound.SC3+> import Sound.OSC {- hosc -}+> import Sound.SC3 {- hsc3 -}  > let d = let {f = control KR "freq" 440 >             ;o = saw AR f * 0.1} >         in synthdef "saw" (out 0 o) -> withSC3 (async (d_recv d) >>->          send (s_new0 "saw" 1000 AddToTail 1))+> withSC3 (async (d_recv d) >> send (s_new0 "saw" 1000 AddToTail 1)) -> r <- withSC3 (send (n_query [1000]) >>->               waitReply "/n_info")+> r <- withSC3 (withNotifications (send (n_query [1000]) >> waitReply "/n_info"))  > print r
Help/Server/notify.help.lhs view
@@ -1,10 +1,17 @@-> Sound.SC3.Server.Help.viewServerHelp "/notify"+     Sound.SC3.Server.Help.viewServerHelp "/notify" -> import Sound.OSC-> import Sound.SC3.ID+> import Sound.OSC {- hosc -}+> import Sound.SC3 {- hsc3 -} -> let g = synthdef "g" (out 0 (sinOsc AR (rand 'a' 440 880) 0 * 0.1))-> in withSC3 (async (d_recv g))+> g_01 = sinOsc AR (rand 'α' 440 880) 0 * 0.1 -> withSC3 (withNotifications (do {send (s_new "g" (-2) AddToHead 1 [])->                                ;waitReply "/n_go"}))+> s_01 = synthdef "g" (out 0 g_01)++> m_01 = s_new "g" (-1) AddToHead 1 []++> f_01 :: DuplexOSC m => m Message+> f_01 = do+>   async_ (d_recv s_01)+>   withNotifications (sendMessage m_01 >> waitReply "/n_go")++    withSC3 (f_01 >>= \r -> liftIO (print r))
− Help/UGen/Analysis/amplitude.help.lhs
@@ -1,16 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Amplitude"-> Sound.SC3.UGen.DB.ugenSummary "Amplitude"--> import Sound.SC3--> let {s = soundIn 4->     ;a = amplitude KR s 0.01 0.01}-> in audition (out 0 (pulse AR 90 0.3 * a))--> let {s = soundIn 4->     ;f = amplitude KR s 0.5 0.5 * 1200 + 400}-> in audition (out 0 (sinOsc AR f 0 * 0.1))--> let {s = soundIn 4->     ;a = amplitude AR s 0.5 0.05}-> in audition (out 0 (s * a))
− Help/UGen/Analysis/compander.help.lhs
@@ -1,33 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Compander"-> Sound.SC3.UGen.DB.ugenSummary "Compander"--> import Sound.SC3--Example signal to process.-> let z = let {e = decay2 (impulse AR 8 0 * lfSaw KR 0.3 0 * 0.3) 0.001 0.3->             ;p = mix (pulse AR (mce [80, 81]) 0.3)}->         in e * p--> let z = soundIn 4--> audition (out 0 z)--Noise gate (no hold, no hysteresis)-> let x = mouseX KR 0.01 0.15 Linear 0.1-> in audition (out 0 (mce [z, compander z z x 10 1 0.002 0.15]))--Compressor-> let x = mouseX KR 0.01 1 Linear 0.1-> in audition (out 0 (mce [z, compander z z x 1 (1/3) 0.01 0.01]))--Expander-> let x = mouseX KR 0.01 1 Linear 0.1-> in audition (out 0 (mce [z, compander z z x 1 3 0.01 0.1]))--Limiter-> let x = mouseX KR 0.01 1 Linear 0.1-> in audition (out 0 (mce [z, compander z z x 1 (1/10) 0.01 0.01]))--Sustainer-> let x = mouseX KR 0.01 0.15 Linear 0.1-> in audition (out 0 (mce [z, compander z z x (1/3) 1.0 0.01 0.05]))
− Help/UGen/Analysis/pitch.help.lhs
@@ -1,27 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Pitch"-> Sound.SC3.UGen.DB.ugenSummary "Pitch"--> import Sound.SC3--> let {x = mouseX KR 220 660 Linear 0.1->     ;y = mouseY KR 0.05 0.25 Linear 0.1->     ;s = sinOsc AR x 0 * y->     ;a = amplitude KR s 0.05 0.05->     ;f = pitch s 440 60 4000 100 16 7 0.02 0.5 1 0}-> in audition (out 0 (mce [s, sinOsc AR (mceChannel 0 f / 2) 0 * a]))--> let {s = soundIn 4->     ;a = amplitude KR s 0.1 0.1->     ;f = pitch s 440 60 4000 100 16 7 0.02 0.5 1 0}-> in audition (out 0 (mce [s, sinOsc AR (mceChannel 0 f) 0 * a]))--Comparison of input frequency (x) and tracked oscillator frequency (f).-Output is printed to the console by scsynth.-> let {x = mouseX KR 440 880 Exponential 0.1->     ;o = sinOsc AR x 0 * 0.1->     ;[f,_] = mceChannels (pitch o 440 60 4000 100 16 7 0.02 0.5 1 0)->     ;r = sinOsc AR f 0 * 0.1->     ;t = impulse KR 4 0->     ;pf = poll t f (label "f") 0->     ;px = poll t x (label "x") 0}-> in audition (mrg [out 0 (mce2 o r),pf,px])
− Help/UGen/Analysis/runningSum.help.lhs
@@ -1,25 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "RunningSum"-> Sound.SC3.UGen.DB.ugenSummary "RunningSum"--> import Sound.SC3--distorts of course - would need scaling-> audition (out 0 (runningSum (soundIn 4) 40))--Running Average over x samples-> let {x = 100->     ;o = runningSum (lfSaw AR 440 0) x * recip x}-> in audition (out 0 o)--RMS Power-> let {input = lfSaw AR 440 0->     ;numsamp = 30->     ;o = runningSum (input * input) numsamp / (sqrt numsamp)}-> in audition (out 0 o)--composite UGen-> audition (out 0 (runningSumRMS (soundIn 4) 40))--> let {z = soundIn 4->     ;a = runningSum z 40}-> in audition (out 0 (sinOsc AR 440 0 * a * 0.1))
− Help/UGen/Analysis/slope.help.lhs
@@ -1,12 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Slope"-> Sound.SC3.UGen.DB.ugenSummary "Slope"--> import Sound.SC3.ID--> let {a = lfNoise2 'a' KR 2 {- quadratic noise -}->     ;s = 1/2->     ;b = slope a * s {- first derivative, line segments -}->     ;c = slope b * squared s {- second derivative, constant segments -}->     ;f = mce [a, b, c] * 220 + 220->     ;o = sinOsc AR f 0 * (1/3)}-> in audition (out 0 (mix o))
− Help/UGen/Analysis/zeroCrossing.help.lhs
@@ -1,7 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "ZeroCrossing"-> Sound.SC3.UGen.DB.ugenSummary "ZeroCrossing"--> import Sound.SC3--> let a = sinOsc AR (sinOsc KR 1 0 * 600 + 700) 0 * 0.1-> in audition (out 0 (mce [a, impulse AR (zeroCrossing a) 0 * 0.25]))
− Help/UGen/Buffer/bufAllpassC.help.lhs
@@ -1,13 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "BufAllpassC"-> Sound.SC3.UGen.DB.ugenSummary "BufAllpassC"--> import Sound.SC3.ID--Allocate buffer-> withSC3 (async (b_alloc 0 44100 1))--Filtered decaying noise bursts-> let {d = dust 'a' AR 1->     ;n = whiteNoise 'a' AR->     ;x = decay d 0.2 * n * 0.25}-> in audition (out 0 (bufAllpassC 0 x 0.25 6))
− Help/UGen/Buffer/bufAllpassL.help.lhs
@@ -1,1 +0,0 @@-See bufAllpassC
− Help/UGen/Buffer/bufAllpassN.help.lhs
@@ -1,1 +0,0 @@-See bufAllpassC
− Help/UGen/Buffer/bufChannels.help.lhs
@@ -1,2 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "BufChannels"-> Sound.SC3.UGen.DB.ugenSummary "BufChannels"
− Help/UGen/Buffer/bufCombC.help.lhs
@@ -1,30 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "BufCombC"-> Sound.SC3.UGen.DB.ugenSummary "BufCombC"--> import Sound.SC3.ID--Allocate buffer zero (required for examples below)-> withSC3 (async (b_alloc 0 44100 1))--Filtered decaying noise bursts-> let {d = dust 'a' AR 1->     ;n = whiteNoise 'a' AR->     ;x = decay d 0.2 * n * 0.25}-> in audition (out 0 (bufCombC 0 x 0.25 6))--Comb filter as resonator. The resonant fundamental is equal to-reciprocal of the delay time.-> let {n = whiteNoise 'a' AR->     ;dt = xLine KR 0.0001 0.01 20 RemoveSynth}-> in audition (out 0 (bufCombC 0 (n * 0.1) dt 0.2))--With negative feedback-> let {n = whiteNoise 'a' AR->     ;dt = xLine KR 0.0001 0.01 20 RemoveSynth}-> in audition (out 0 (bufCombC 0 (n * 0.1) dt (-0.2)))--Used as an echo.-> let {d = dust 'a' AR 1->     ;n = whiteNoise 'a' AR->     ;i = decay (d * 0.5) 0.2 * n}-> in audition (out 0 (bufCombC 0 i 0.2 3))
− Help/UGen/Buffer/bufCombL.help.lhs
@@ -1,1 +0,0 @@-See bufCombC
− Help/UGen/Buffer/bufCombN.help.lhs
@@ -1,1 +0,0 @@-See bufCombC
− Help/UGen/Buffer/bufDelayC.help.lhs
@@ -1,21 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "BufDelayC"-> Sound.SC3.UGen.DB.ugenSummary "BufDelayC"--> import Sound.SC3.ID--Allocate buffer zero (required for examples below)-> withSC3 (async (b_alloc 0 44100 1))--Dust randomly triggers Decay to create an exponential decay envelope-for the WhiteNoise input source.  The input is mixed with the delay.-> let {t = dust 'a' AR 1->     ;n = whiteNoise 'a' AR->     ;d = decay t 0.5 * n * 0.3}-> in audition (out 0 (bufDelayC 0 d 0.2 + d))--Mouse control for delay time-> let {t = dust 'a' AR 1->     ;n = whiteNoise 'b' AR->     ;d = decay t 0.3 * n->     ;x = mouseX KR 0.0 0.2 Linear 0.1}-> in audition (out 0 (d + bufDelayC 0 d x))
− Help/UGen/Buffer/bufDelayL.help.lhs
@@ -1,1 +0,0 @@-See bufDelayC
− Help/UGen/Buffer/bufDelayN.help.lhs
@@ -1,1 +0,0 @@-See bufDelayC
− Help/UGen/Buffer/bufDur.help.lhs
@@ -1,15 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "BufDur"-> Sound.SC3.UGen.DB.ugenSummary "BufDur"--> import Sound.SC3--Load sound file to buffer zero (required for examples)--> let fn = "/home/rohan/data/audio/pf-c5.aif"-> in withSC3 (async (b_allocRead 0 fn 0 0))--Read without loop, trigger reset based on buffer duration--> let {t = impulse AR (recip (bufDur KR 0)) 0->     ;p = sweep t (bufSampleRate KR 0)}-> in audition (out 0 (bufRdL 1 AR 0 p NoLoop))
− Help/UGen/Buffer/bufFrames.help.lhs
@@ -1,17 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "BufFrames"-> Sound.SC3.UGen.DB.ugenSummary "BufFrames"--> import Sound.SC3--Load sound file to buffer zero (required for examples)-> let fn = "/home/rohan/data/audio/pf-c5.aif"-> in withSC3 (async (b_allocRead 0 fn 0 0))--Read without loop, trigger reset based on buffer duration-> let p = phasor AR 0 (bufRateScale KR 0) 0 (bufFrames KR 0) 0-> in audition (out 0 (bufRdL 1 AR 0 p NoLoop))--Mouse location drags play head-> let {r = mce [0.05,0.075 .. 0.15]->     ;p = k2A (mouseX KR 0 (bufFrames KR 0) Linear r)}-> in audition (out 0 (mix (bufRdL 1 AR 0 p NoLoop)))
− Help/UGen/Buffer/bufRateScale.help.lhs
@@ -1,13 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "BufRateScale"-> Sound.SC3.UGen.DB.ugenSummary "BufRateScale"--> import Sound.SC3.ID--Load sound file to buffer zero (required for examples)-> let fn = "/home/rohan/data/audio/pf-c5.aif"-> in withSC3 (async (b_allocRead 0 fn 0 0))--Read buffer at 3/4 reported sample rate.-> let {r = 0.75 * bufRateScale KR 0->     ;p = phasor AR 0 r 0 (bufFrames KR 0) 0}-> in audition (out 0 (bufRdL 1 AR 0 p NoLoop))
− Help/UGen/Buffer/bufRd.help.lhs
@@ -1,38 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "BufRd"-> Sound.SC3.UGen.DB.ugenSummary "BufRd"--> import Sound.SC3.ID {- hsc3 -}--Load sound file to buffer zero (required for examples)--> let fn = "/home/rohan/data/audio/pf-c5.aif"-> in withSC3 (async (b_allocRead 0 fn 0 0))--Phasor as phase input--> let {sc = bufRateScale KR 0->     ;tr = impulse AR (recip (bufDur KR 0)) 0->     ;ph = phasor AR tr sc 0 (bufFrames KR 0) 0}-> in audition (out 0 (bufRdL 1 AR 0 ph NoLoop))--Audio rate sine oscillator as phase input--> let phase = sinOsc AR 0.1 0 * bufFrames KR 0 * bufRateScale KR 0-> in audition (out 0 (bufRd 1 AR 0 phase Loop NoInterpolation))--There are constructors, bufRd{N|L|C}, for the fixed cases.--> let {x = mouseX KR (mce [5, 10]) 100 Linear 0.1->     ;n = lfNoise1 'α' AR x}-> in audition (out 0 (bufRdL 1 AR 0 (n * bufFrames KR 0 * bufRateScale KR 0) Loop))--Allocate and generate (non-wavetable) buffer--> withSC3 (do {_ <- async (b_alloc 11 256 1)->             ;let f = [Normalise,Clear]->              in send (b_gen_sine1 11 f [1,1/2,1/3,1/4,1/5])})--Fixed frequency wavetable oscillator--> let phase = linLin (saw AR 440) (-1) 1 0 1 * bufFrames KR 11-> in audition (out 0 (bufRd 1 AR 11 phase Loop NoInterpolation * 0.1))
− Help/UGen/Buffer/bufSampleRate.help.lhs
@@ -1,12 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "BufSampleRate"-> Sound.SC3.UGen.DB.ugenSummary "BufSampleRate"--> import Sound.SC3--Load sound file to buffer zero (required for examples)-> let fn = "/home/rohan/data/audio/pf-c5.aif"-> in withSC3 (async (b_allocRead 0 fn 0 0))--Sine tone derived from sample rate of buffer an 440Hz tone.-> let f = mce [bufSampleRate KR 0 * 0.01, 440]-> in audition (out 0 (sinOsc AR f 0 * 0.1))
− Help/UGen/Buffer/detectIndex.help.lhs
@@ -1,16 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "DetectIndex"-> Sound.SC3.UGen.DB.ugenSummary "DetectIndex"--> import Sound.SC3--Allocate and set values at buffer ten-> withSC3 (async (b_alloc_setn1 10 0 [2,3,4,0,1,5]))--Find indexes and map to an audible frequency range.-> let {n = 6->     ;x = floorE (mouseX KR 0 n Linear 0.1)->     ;i = detectIndex 10 x}-> in audition (out 0 (sinOsc AR (linExp i 0 n 200 700) 0 * 0.1))--Free buffer.-> withSC3 (send (b_free 10))
− Help/UGen/Buffer/index.help.lhs
@@ -1,14 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Index"-> Sound.SC3.UGen.DB.ugenSummary "Index"--> import Sound.SC3--Allocate and set values at buffer ten-> withSC3 (async (b_alloc_setn1 10 0 [50,100,200,400,800,1600]))--Index buffer for frequency values-> let f = index 10 (lfSaw KR 2 3 * 4)-> in audition (out 0 (sinOsc AR (mce [f,f * 9]) 0 * 0.1))--Free buffer-> withSC3 (send (b_free 10))
− Help/UGen/Buffer/indexInBetween.help.lhs
@@ -1,18 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "IndexInBetween"-> Sound.SC3.UGen.DB.ugenSummary "IndexInBetween"--> import Sound.SC3--Allocate and set values at buffer ten-> withSC3 (async (b_alloc_setn1 10 0 [200,210,400,430,600,800]))--Index into buffer for frequency values-> let {f0 = mouseX KR 200 900 Linear 0.1->     ;i = indexInBetween 10 f0->     ;l0 = index 10 i->     ;l1 = index 10 (i + 1)->     ;f1 = linLin (frac i) 0 1 l0 l1}-> in audition (out 0 (sinOsc AR (mce [f0,f1]) 0 * 0.1))--Free buffer-> withSC3 (send (b_free 10))
− Help/UGen/Buffer/osc.help.lhs
@@ -1,45 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Osc"-> Sound.SC3.UGen.DB.ugenSummary "Osc"--> import Sound.SC3--Allocate and generate wavetable buffer--> withSC3 (do {_ <- async (b_alloc 10 512 1)->             ;let f = [Normalise,Wavetable,Clear]->              in send (b_gen_sine1 10 f [1,1/2,1/3,1/4,1/5])})--Fixed frequency wavetable oscillator--> audition (out 0 (osc AR 10 220 0 * 0.1))--Modulate frequency--> let f = xLine KR 2000 200 1 DoNothing-> in audition (out 0 (osc AR 10 f 0 * 0.1))--As frequency modulator--> let f = osc AR 10 (xLine KR 1 1000 9 RemoveSynth) 0 * 200 + 800-> in audition (out 0 (osc AR 10 f 0 * 0.1))--As phase modulatulator--> let p = osc AR 10 (xLine KR 20 8000 10 RemoveSynth) 0 * 2 * pi-> in audition (out 0 (osc AR 10 800 p * 0.1))--Fixed frequency wavetable oscillator--> audition (out 0 (osc AR 10 220 0 * 0.1))--Change the wavetable while its playing--> let f = [Normalise,Wavetable,Clear]-> in withSC3 (send (b_gen_sine1 10 f [1,0.6,1/4]))--Send directly calculated wavetable--> import Sound.SC3.Lang.Collection {- hsc3-lang -}-> import Sound.SC3.Lang.Math.Window-> let t = to_wavetable (triangular_table 512)-> withSC3 (send (b_setn1 10 0 t))
− Help/UGen/Buffer/playBuf.help.lhs
@@ -1,85 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "PlayBuf"-> Sound.SC3.UGen.DB.ugenSummary "PlayBuf"--> import Sound.SC3--Load sound file to buffer zero (single channel file required for examples)--> let fn = "/home/rohan/data/audio/pf-c5.aif"-> in withSC3 (async (b_allocRead 0 fn 0 0))--Play once only.--> let s = bufRateScale KR 0-> in audition (out 0 (playBuf 1 AR 0 s 1 0 NoLoop RemoveSynth))--Play in infinite loop.--> let s = bufRateScale KR 0-> in audition (out 0 (playBuf 1 AR 0 s 1 0 Loop DoNothing))--Trigger playback at each pulse.--> let {t = impulse KR 2 0->     ;s = bufRateScale KR 0}-> in audition (out 0 (playBuf 1 AR 0 s t 0 NoLoop DoNothing))--Trigger playback at each pulse (diminishing intervals).--> let {f = xLine KR 0.1 100 10 RemoveSynth->     ;t = impulse KR f 0->     ;s = bufRateScale KR 0}-> in audition (out 0 (playBuf 1 AR 0 s t 0 NoLoop DoNothing))--Loop playback, accelerating pitch.--> let r = xLine KR 0.1 100 60 RemoveSynth-> in audition (out 0 (playBuf 1 AR 0 r 1 0 Loop DoNothing))--Sine wave control of playback rate, negative rate plays backwards.--> let {f = xLine KR 0.2 8 30 RemoveSynth->     ;r = fSinOsc KR f 0 * 3 + 0.6->     ;s = bufRateScale KR 0 * r}-> in audition (out 0 (playBuf 1 AR 0 s 1 0 Loop DoNothing))--Release buffer.--> withSC3 (send (b_free 0))--Channel mismatch, single channel buffer, two channel playBuf, result-is silence and channel mismatch message in server log.--> let fn = "/home/rohan/data/audio/pf-c5.aif"-> in withSC3 (async (b_allocRead 0 fn 0 0))--> let s = bufRateScale KR 0-> in audition (out 0 (playBuf 2 AR 0 s 1 0 Loop DoNothing))--Graph will sound after loading a two channel signal to buffer, and-stop again after loading a single channel sound file.--> let fn = "/home/rohan/data/audio/sp/tinguely.aif"-> in withSC3 (async (b_allocRead 0 fn 0 0))--Scan sequence of buffers:--> let {n = 29 * 6->     ;b = mouseX KR 0 n Linear 0.2->     ;r = bufRateScale KR b}-> in audition (out 0 (playBuf 1 AR b r 1 0 Loop DoNothing))--In sclanguage:--{var fn = "/home/rohan/data/audio/pf-c5.aif"-;s.sendMsg("/b_allocRead",0,fn,0,0)}.value--{var sc = BufRateScale.kr(0)-;Out.ar(0,PlayBuf.ar(2,0,sc,1,0,1,0))}.play--{var fn = "/home/rohan/data/audio/sp/tinguely.aif"-;s.sendMsg("/b_allocRead",0,fn,0,0)}.value--{var b = MouseX.kr(32,64,0,0.2)-;var r = BufRateScale.kr(b)-;Out.ar(0,PlayBuf.ar(1,b,r,1,0,1,0))}.play
− Help/UGen/Buffer/recordBuf.help.lhs
@@ -1,25 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "RecordBuf"-> Sound.SC3.UGen.DB.ugenSummary "RecordBuf"--> import Sound.SC3--Allocate a buffer (assume SR of 48k)--> withSC3 (async (b_alloc 0 (48000 * 4) 1))--Record for four seconds (until end of buffer)--> let o = formant AR (xLine KR 400 1000 4 DoNothing) 2000 800 * 0.125-> in audition (mrg2 (out 0 o)->                   (recordBuf AR 0 0 1 0 1 NoLoop 1 RemoveSynth o))--Play it back--> let p = playBuf 1 AR 0 1 1 0 NoLoop RemoveSynth-> in audition (out 0 p)--Mix second signal equally with existing signal, replay to hear--> let o = formant AR (xLine KR 200 1000 4 DoNothing) 2000 800 * 0.125-> in audition (mrg2 (out 0 o)->                   (recordBuf AR 0 0 0.5 0.5 1 NoLoop 1 RemoveSynth o))
− Help/UGen/Buffer/vOsc.help.lhs
@@ -1,31 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "VOsc"-> Sound.SC3.UGen.DB.ugenSummary "VOsc"--> import Sound.SC3--Allocate and fill tables 0 to 7.--> let {square a = a * a->     ;bf = [Normalise,Wavetable,Clear]->     ;harm i = let {n = square (i + 1)->                   ;f j = square ((n - j) / n)}->                in map f [0 .. n - 1]->     ;setup i = do {i' <- return (fromIntegral i)->                   ;_ <- async (b_alloc i 1024 1)->                   ;send (b_gen_sine1 i bf (harm i'))}}-> in withSC3 (mapM_ setup [0 .. 7])--Oscillator at buffers 0 through 7, mouse selects buffer.--> let {x = mouseX KR 0 7 Linear 0.1->     ;y = mouseY KR 0.01 0.2 Exponential 0.2}-> in audition (out 0 (vOsc AR x (mce [120, 121]) 0 * y))--> import Sound.SC3.Lang.Random.IO {- hsc3-lang -}--Reallocate buffers while oscillator is running.--> let {bf = [Normalise,Wavetable,Clear]->     ;resetTable i = do {h <- nrrand 12 0 1->                        ;send (b_gen_sine1 i bf h)}}-> in withSC3 (mapM_ resetTable [0 .. 7])
− Help/UGen/Buffer/vOsc3.help.lhs
@@ -1,24 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "VOsc3"-> Sound.SC3.UGen.DB.ugenSummary "VOsc3"--> import Sound.SC3--allocate and fill tables 0 to 7.--> let {square a = a * a->     ;bf = [Normalise,Wavetable,Clear]->     ;harm i = let {n = square (i + 1)->                   ;f j = square ((n - j) / n)}->                in map f [0 .. n - 1]->     ;setup i = do {i' <- return (fromIntegral i)->                   ;_ <- async (b_alloc i 1024 1)->                   ;send (b_gen_sine1 i bf (harm i'))}}-> in withSC3 (mapM_ setup [0 .. 7])--oscillator at buffers 0 through 7, mouse selects buffer.--> let {x = mouseX KR 0 7 Linear 0.1->     ;y = mouseY KR 0.01 0.2 Exponential 0.2->     ;o1 = vOsc3 AR x 120 121 129->     ;o2 = vOsc3 AR x 119 123 127}-> in audition (out 0 (mce2 o1 o2 * y))
− Help/UGen/Chaos/crackle.help.lhs
@@ -1,10 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Crackle"-> Sound.SC3.UGen.DB.ugenSummary "Crackle"--> import Sound.SC3--> audition (out 0 (crackle AR 1.95 * 0.2))--Modulate chaos parameter--> audition (out 0 (crackle AR (line KR 1.0 2.0 3 RemoveSynth) * 0.2))
− Help/UGen/Chaos/cuspL.help.lhs
@@ -1,19 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "CuspL"-> Sound.SC3.UGen.DB.ugenSummary "CuspL"--> import Sound.SC3--Vary frequency-> let x = mouseX KR 20 sampleRate Linear 0.1-> in audition (out 0 (cuspL AR x 1.0 1.99 0 * 0.3))--Mouse-controlled parameters.-> let {x = mouseX KR 0.9 1.1 Linear 0.1->     ;y = mouseY KR 1.8 2.0 Linear 0.1}-> in audition (out 0 (cuspL AR (sampleRate / 4) x y 0 * 0.3))--As frequency control.-> let {x = mouseX KR 0.9 1.1 Linear 0.1->     ;y = mouseY KR 1.8 2.0 Linear 0.1->     ;n = cuspL AR 40 x y 0 * 0.3}-> in audition (out 0 (sinOsc AR (n * 800 + 900) 0 * 0.4))
− Help/UGen/Chaos/cuspN.help.lhs
@@ -1,1 +0,0 @@-See cuspL
− Help/UGen/Chaos/fbSineC.help.lhs
@@ -1,29 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "FBSineC"-> Sound.SC3.UGen.DB.ugenSummary "FBSineC"--> import Sound.SC3.ID--SC3 default values.-> let o = fbSineC AR (sampleRate / 4) 1 0.1 1.1 0.5 0.1 0.1 * 0.2-> in audition (out 0 o)--Increase feedback-> let {fb = line KR 0.01 4 10 DoNothing->     ;o = fbSineC AR sampleRate 1 fb 1.1 0.5 0.1 0.1 * 0.2}-> in audition (out 0 o)--Increase phase multiplier-> let {a = line KR 1 2 10 DoNothing->     ;o = fbSineC AR sampleRate 1 0 a 0.5 0.1 0.1 * 0.2}-> in audition (out 0 o)--Randomly modulate parameters-> let {madd a m = (+ a) . (* m)->     ;x = mouseX KR 1 12 Linear 0.1->     ;n e = lfNoise2 e KR x->     ;n0 = madd 1e4 1e4 (n 'a')->     ;n1 = madd 33 32 (n 'b')->     ;n2 = madd 0 0.5 (n 'c')->     ;n3 = madd 1.05 0.05 (n 'd')->     ;n4 = madd 0.3 0.3 (n 'e')}-> in audition (out 0 (fbSineC AR n0 n1 n2 n3 n4 0.1 0.1 * 0.2))
− Help/UGen/Chaos/fbSineL.help.lhs
@@ -1,1 +0,0 @@-See fbSineC
− Help/UGen/Chaos/fbSineN.help.lhs
@@ -1,1 +0,0 @@-See fbSineC
− Help/UGen/Chaos/gbmanL.help.lhs
@@ -1,1 +0,0 @@-See GbmanN
− Help/UGen/Chaos/gbmanN.help.lhs
@@ -1,20 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "GbmanN"-> Sound.SC3.UGen.DB.ugenSummary "GbmanN"--> import Sound.SC3--default initial params-> let x = mouseX KR 20 sampleRate Linear 0.2-> in audition (out 0 (gbmanN AR x 1.2 2.1 * 0.1))--change initial params-> let x = mouseX KR 20 sampleRate Linear 0.2-> in audition (out 0 (gbmanN AR x (-0.7) (-2.7) * 0.1))--wait for it...-> let x = mouseX KR 20 sampleRate Linear 0.2-> in audition (out 0 (gbmanN AR x 1.2 2.0002 * 0.1))--as a frequency control-> let f = gbmanN AR 40 1.2 2.1 * 400 + 500-> in audition (out 0 (sinOsc AR f 0 * 0.4))
− Help/UGen/Chaos/henonC.help.lhs
@@ -1,1 +0,0 @@-See henonN
− Help/UGen/Chaos/henonL.help.lhs
@@ -1,1 +0,0 @@-See henonN
− Help/UGen/Chaos/henonN.help.lhs
@@ -1,25 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "HenonN"-> Sound.SC3.UGen.DB.ugenSummary "HenonN"--> import Sound.SC3.ID--With SC3 default initial parameters.-> let x = mouseX KR 20 sampleRate Linear 0.1-> in audition (out 0 (henonN AR x 1.4 0.3 0 0 * 0.1))--With mouse-control of parameters.-> let {x = mouseX KR 1 1.4 Linear 0.1->     ;y = mouseY KR 0 0.3 Linear 0.1}-> in audition (out 0 (henonN AR (sampleRate / 4) x y 0 0 * 0.1))--With randomly modulated parameters.-> let {n0 = lfNoise2 'a' KR 1 * 0.20 + 1.20->     ;n1 = lfNoise2 'a' KR 1 * 0.15 + 0.15}-> in audition (out 0 (henonN AR (sampleRate / 8) n0 n1 0 0 * 0.1))--As a frequency control.-> let {x = mouseX KR 1 1.4 Linear 0.1->     ;y = mouseY KR 0 0.3 Linear 0.1->     ;f0 = 40->     ;f = henonN AR f0 x y 0 0 * 800 + 900}-> in audition (out 0 (sinOsc AR f 0 * 0.4))
− Help/UGen/Chaos/latoocarfianC.help.lhs
@@ -1,18 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "LatoocarfianC"-> Sound.SC3.UGen.DB.ugenSummary "LatoocarfianC"--> import Sound.SC3.ID--SC3 default initial parameters.-> let x = mouseX KR 20 sampleRate Linear 0.1-> in audition (out 0 (latoocarfianC AR x 1 3 0.5 0.5 0.5 0.5 * 0.2))--Randomly modulate all parameters.-> let {[n0,n1,n2,n3] = map (\e -> lfNoise2 e KR 5) "abcd"->     ;f = sampleRate / 4->     ;a = n0 * 1.5 + 1.5->     ;b = n1 * 1.5 + 1.5->     ;c = n2 * 0.5 + 1.5->     ;d = n3 * 0.5 + 1.5->     ;o = latoocarfianC AR f a b c d 0.5 0.5 * 0.2}-> in audition (out 0 o)
− Help/UGen/Chaos/linCongC.help.lhs
@@ -1,16 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "LinCongC"-> Sound.SC3.UGen.DB.ugenSummary "LinCongC"--> import Sound.SC3.ID--Default SC3 initial parameters.-> let x = mouseX KR 20 sampleRate Linear 0.1-> in audition (out 0 (linCongC AR x 1.1 0.13 1 0 * 0.2))--Randomly modulate parameters.-> let {fr = [1,0.1,0.1,0.1]->     ;[n0,n1,n2,m] = map (\(i,j) -> lfNoise2 i KR j) (zip "abde" fr)->     ;f = n0 * 1e4 + 1e4->     ;a = n1 * 0.5 + 1.4->     ;c = n2 * 0.1 + 0.1}-> in audition (out 0 (linCongC AR f a c m 0 * 0.2))
− Help/UGen/Chaos/linCongL.help.lhs
@@ -1,1 +0,0 @@-See linCongC
− Help/UGen/Chaos/linCongN.help.lhs
@@ -1,1 +0,0 @@-See linCongC
− Help/UGen/Chaos/logistic.help.lhs
@@ -1,15 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Logistic"-> Sound.SC3.UGen.DB.ugenSummary "Logistic"--> import Sound.SC3--SC3 default parameters-> audition (out 0 (logistic AR 3 1000 0.5))--Onset of chaos-> audition (out 0 (logistic AR (line KR 3.55 3.6 5 DoNothing) 1000 0.01))--Mouse control-> let {x = mouseX KR 3 3.99 Linear 0.1->     ;y = mouseY KR 10 10000 Exponential 0.1}-> in audition (out 0 (logistic AR x y 0.25 * 0.5))
− Help/UGen/Chaos/lorenzL.help.lhs
@@ -1,22 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "LorenzL"-> Sound.SC3.UGen.DB.ugenSummary "LorenzL"--> import Sound.SC3.ID--Vary frequency-> let x = mouseX KR 20 sampleRate Linear 0.1-> in audition (out 0 (lorenzL AR x 10 27 2.667 0.05 0.1 0 0 * 0.3))--Randomly modulate params-> let {madd a m = (+ a) . (* m)->     ;n e = lfNoise0 e KR 0.5->     ;n0 = madd 10 2 (n 'a')->     ;n1 = madd 38 20 (n 'b')->     ;n2 = madd 2 1.5 (n 'c')->     ;o = lorenzL AR sampleRate n0 n1 n2 0.05 0.1 0 0 * 0.2}-> in audition (out 0 o)--As frequency control-> let {x = mouseX KR 1 200 Linear 0.1->     ;n = lorenzL AR x 10 28 2.667 0.05 0.1 0 0}-> in audition (out 0 (sinOsc AR (lag n 0.003 * 800 + 900) 0 * 0.4))
− Help/UGen/Chaos/quadC.help.lhs
@@ -1,1 +0,0 @@-See quadN
− Help/UGen/Chaos/quadL.help.lhs
@@ -1,1 +0,0 @@-See quadN
− Help/UGen/Chaos/quadN.help.lhs
@@ -1,13 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "QuadN"-> Sound.SC3.UGen.DB.ugenSummary "QuadN"--> import Sound.SC3--> audition (out 0 (quadC AR 4000 1 (-1) (-0.75) 0 * 0.2))--> let x = mouseX KR 3.5441 4 Linear 0.1-> in audition (out 0 (quadC AR 4000 (negate x) x 0 0.1 * 0.4))--> let {x = mouseX KR 3.5441 4 Linear 0.1->     ;f = quadC AR 4 (negate x) x 0 0.1 * 800 + 900}-> in audition (out 0 (sinOsc AR f 0 * 0.4))
− Help/UGen/Chaos/rossler.help.lhs
− Help/UGen/Control/mrg2.help.lhs
@@ -1,24 +0,0 @@-> :t mrg2--> import Sound.SC3--mrg2 defines a node indicating a multiple root graph.-> let {l = out 0 (sinOsc AR 300 0 * 0.1)->     ;r = out 1 (sinOsc AR 900 0 * 0.1)}-> in audition (mrg2 l r)--there is a leftmost rule, so that mrg nodes need not-be terminal.-> let {l = sinOsc AR 300 0 * 0.1->     ;r = out 1 (sinOsc AR 900 0 * 0.1)}-> in audition (out 0 (mrg2 l r))--the leftmost node may be an mce node-> let {l = sinOsc AR (mce2 300 400) 0 * 0.1->     ;r = out 1 (sinOsc AR 900 0 * 0.1)}-> in audition (out 0 (mrg2 l r))--the implementation is not thorough-> let {l = sinOsc AR (mce2 300 400) 0 * 0.1->     ;r = out 1 (sinOsc AR 900 0 * 0.1)}-> in audition (out 0 (mrg2 l r + mrg2 l r))
− Help/UGen/Control/trigControl.help.lhs
@@ -1,38 +0,0 @@-> import Sound.SC3 {- hsc3 -}--Graph with the three types of non-audio controls.--> let u = let {freq = control KR "freq" 440->             ;phase = control IR "phase" 0->             ;gate = tr_control "gate" 1->             ;amp = control KR "amp" 0.1->             ;e = envGen KR gate amp 0 1 DoNothing (envASR 0.01 0.1 1 EnvLin)}->         in sinOsc AR freq phase * e--Make a drawing--> import Sound.SC3.UGen.Dot {- hsc3-ugen -}--> draw (out 0 u)--Listen--> audition_at (10,AddToHead,1) (out 0 u)--Set frequency and the trigger gate.--> withSC3 (send (n_set1 10 "freq" 2200))--> withSC3 (send (n_set1 10 "gate" 1))--Make a control rate graph to write freq and gate values.--> let c = out 0 (mce2 (tRand 'α' 220 2200 (dust 'β' KR 1)) (dust 'γ' KR 3))--Add it _before_ the node it will map to, the trigger is only on the bus for the current cycle.--> audition_at (-1,AddBefore,10) c--Map the control values at the audio graph.--> withSC3 (send (n_map 10 [("freq",0),("gate",1)]))
− Help/UGen/Demand/dbrown.help.lhs
@@ -1,10 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Dbrown"-> Sound.SC3.UGen.DB.ugenSummary "Dbrown"--> import Sound.SC3.ID--> let {n = dbrown 'α' dinf 0 15 1->     ;x = mouseX KR 1 40 Exponential 0.1->     ;t = impulse KR x 0->     ;f = demand t 0 n * 30 + 340}-> in audition (out 0 (sinOsc AR f 0 * 0.1))
− Help/UGen/Demand/dbufrd.help.lhs
@@ -1,40 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Dbufrd"-> Sound.SC3.UGen.DB.ugenSummary "Dbufrd"--> import Sound.SC3.ID {- hsc3 -}-> import System.Random {- random -}--setup pattern at buffer 10--> let n = randomRs (200.0,500.0) (mkStdGen 0)-> in withSC3 (async (b_alloc_setn1 10 0 (take 24 n)))--pattern as frequency input--> let {s = dseq 'α' 3 (mce [0,3,5,0,3,7,0,5,9])->     ;b = dbrown 'β' 5 0 23 1->     ;p = dseq 'γ' dinf (mce [s,b])->     ;t = dust 'δ' KR 10->     ;r = dbufrd 'ε' 10 p Loop}-> in audition (out 0 (sinOsc AR (demand t 0 r) 0 * 0.1))--setup time pattern--> let {i = randomRs (0,2) (mkStdGen 0)->     ;n = map ([1,0.5,0.25] !!) i}-> in withSC3 (async (b_alloc_setn1 11 0 (take 24 n)))--requires buffers 10 and 11 as allocated above--> let {s = dseq 'α' 3 (mce [0,3,5,0,3,7,0,5,9])->     ;b = dbrown 'β' 5 0 23 1->     ;p = dseq 'γ' dinf (mce [s,b])->     ;j = dseries 'δ' dinf 0 1->     ;d = dbufrd 'ε' 11 j Loop->     ;l = dbufrd 'ζ' 10 p Loop->     ;f = duty KR (d * 0.5) 0 DoNothing l}-> in audition (out 0 (sinOsc AR f 0 * 0.1))--free buffers--> withSC3 (async (b_free 10) >> async (b_free 11))
− Help/UGen/Demand/dbufwr.help.lhs
@@ -1,23 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Dbufwr"-> Sound.SC3.UGen.DB.ugenSummary "Dbufwr"--> import Sound.SC3 {- hsc3 -}-> import qualified Sound.SC3.Monad as M {- hsc3 -}--> do {s1 <- M.dseries 30 0 3->    ;s2 <- M.dseries 30 0 1->    ;s3 <- M.dseries 16 1 1->    ;s4 <- M.dwhite 8 1 16->    ;s5 <- M.dseq dinf (mce2 s3 s4)->    ;wt <- M.dust KR 1                  {- write trigger -}->    ;rp <- M.dseries dinf 0 1           {- read pointer -}->    ;wp <- M.dseq dinf (mce2 s1 s2)     {- write pointer -}->    ;r <- M.dbufrd 0 rp Loop            {- reader -}->    ;w <- M.dbufwr 0 wp (s5 * 60) Loop  {- writer -}->    ;let {d = demand wt 0 w->         ;f = lag (demand (impulse KR 16 0) 0 r) 0.01->         ;o = sinOsc AR (f * mce2 1 1.01) 0 * 0.1->         ;g = mrg [d, out 0 o]->         ;run = do {_ <- async (b_alloc_setn1 0 0 (replicate 24 210))->                   ;play g}}->     in withSC3 run}
− Help/UGen/Demand/demand.help.lhs
@@ -1,32 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Demand"-> Sound.SC3.UGen.DB.ugenSummary "Demand"--> import Sound.SC3.ID-> import qualified Sound.SC3.Monad as M--> do {r <- M.dust KR 1->    ;s <- M.dgeom dinf (midiCPS 72) (midiRatio 1)->    ;let {t = impulse KR 10 0->         ;f = demand t r s->         ;o = sinOsc AR (mce [f,f + 0.7]) 0}->     in audition (out 0 (max (cubed o) 0 * 0.1))}--> let {n = diwhite 'α' dinf 60 72->     ;t = impulse KR 10 0->     ;s = midiCPS n->     ;f = demand t 0 s->     ;o = sinOsc AR (mce [f,f + 0.7]) 0}-> in audition (out 0 (cubed (cubed o) * 0.1))--audio rate (poll output is equal for x1 and x2)--> let {i = lfNoise2 'α' AR 8000->     ;d = dseq 'β' dinf (mce [i])->     ;x = mouseX KR 1 3000 Exponential 0.2->     ;t = impulse AR x 0->     ;x1 = demand t 0 d->     ;x2 = latch i t->     ;s = mce2 x1 x2->     ;p = poll t s (mce2 (label "x1") (label "x2")) 0->     ;o = sinOsc AR (s * 300 + 400) 0 * 0.1}-> in audition (mrg2 (out 0 o) p)
− Help/UGen/Demand/demandEnvGen.help.lhs
@@ -1,91 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "DemandEnvGen"-> Sound.SC3.UGen.DB.ugenSummary "DemandEnvGen"--> import Sound.SC3.ID--Frequency ramp, exponential curve.--> let {l = dseq 'α' dinf (mce2 440 9600)->     ;y = mouseY KR 0.01 3 Exponential 0.2->     ;s = env_curve_shape EnvExp->     ;f = demandEnvGen AR l y s 0 1 1 1 0 1 DoNothing}-> in audition (out 0 (sinOsc AR f 0 * 0.1))--Frequency envelope with random times.--> let {l = dseq 'α' dinf (mce [204,400,201,502,300,200])->     ;t = drand 'β' dinf (mce [1.01,0.2,0.1,2.0])->     ;y = mouseY KR 0.01 3 Exponential 0.2->     ;s = env_curve_shape EnvCub->     ;f = demandEnvGen AR l (t * y) s 0 1 1 1 0 1 DoNothing}-> in audition (out 0 (sinOsc AR (f * mce2 1 1.01) 0 * 0.1))--Frequency modulation--> let {n = dwhite 'α' dinf 200 1000->     ;x = mouseX KR (-0.01) (-4) Linear 0.2->     ;y = mouseY KR 1 3000 Exponential 0.2->     ;s = env_curve_shape (EnvNum undefined)->     ;f = demandEnvGen AR n (sampleDur * y) s x 1 1 1 0 1 DoNothing->     ;o = sinOsc AR f 0 * 0.1}-> in audition (out 0 o)--Short sequence with doneAction, linear--> let {l = dseq 'α' 1 (mce [1300,500,800,300,400])->     ;s = env_curve_shape EnvLin->     ;f = demandEnvGen KR l 2 s 0 1 1 1 0 1 RemoveSynth}-> in audition (out 0 (sinOsc AR (f * mce2 1 1.01) 0 * 0.1))--Gate, mouse x on right side of screen toggles gate--> let {n = roundTo (dwhite 'α' dinf 300 1000) 100->     ;x = mouseX KR 0 1 Linear 0.2->     ;g = x >* 0.5->     ;f = demandEnvGen AR n 0.1 5 0.3 g 1 1 0 1 DoNothing->     ;o = sinOsc AR (f * mce2 1 1.21) 0 * 0.1}-> in audition (out 0 o)--gate-mouse x on right side of screen toggles sample and hold-mouse button does hard reset--> let {l = dseq 'α' 2 (mce [dseries 'β' 5 400 200,500,800,530,4000,900])->     ;x = mouseX KR 0 1 Linear 0.2->     ;g = (x >* 0.5) - 0.1->     ;b = mouseButton KR 0 1 0.2->     ;r = (b >* 0.5) * 2->     ;s = env_curve_shape EnvSin->     ;f = demandEnvGen KR l 0.1 s 0 g r 1 0 1 DoNothing->     ;o = sinOsc AR (f * mce2 1 1.001) 0 * 0.1}-> in audition (out 0 o)--initialise coordinate buffer-layout is (initial-level,duration,level,..,loop-duration)--> withSC3 (async (b_alloc_setn1 0 0 [0,0.5,0.1,0.5,1,0.01]))--> let {b = 0->     ;l_i = dseries 'β' dinf 0 2->     ;d_i = dseries 'γ' dinf 1 2->     ;l = dbufrd 'δ' b l_i Loop->     ;d = dbufrd 'ε' b d_i Loop->     ;s = env_curve_shape EnvLin->     ;e = demandEnvGen KR l d s 0 1 1 1 0 5 RemoveSynth->     ;f = midiCPS (60 + (e * 12))}-> in audition (out 0 (sinOsc AR (f * mce2 1 1.01) 0 * 0.1))--change envelope by setting values or indeed reallocating buffer--> withSC3 (send (b_set1 0 1 0.1))-> withSC3 (async (b_alloc_setn1 0 0 [0.5,0.9,0.1,0.1,1,0.01]))--read envelope break-points from buffer, here simply duration/level pairs.-the behavior is odd if the curve is zero (ie. flat segments).--> let {b = asLocalBuf 'α' [61,1,60,2,72,1,55,5,67,9,67]->     ;lvl = dbufrd 'β' b (dseries 'γ' 6 0 2) Loop->     ;dur = dbufrd 'δ' b (dseries 'ε' 5 1 2) Loop->     ;e = demandEnvGen KR lvl dur 1 0 1 1 1 0 1 RemoveSynth->     ;o = sinOsc AR (midiCPS e) 0 * 0.1}-> in audition (out 0 o)
− Help/UGen/Demand/dgeom.help.lhs
@@ -1,10 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Dgeom"-> Sound.SC3.UGen.DB.ugenSummary "Dgeom"--> import Sound.SC3.ID--> let {n = dgeom 'α' 15 1 1.2->     ;x = mouseX KR 1 40 Exponential 0.1->     ;t = impulse KR x 0->     ;f = demand t 0 n * 30 + 340}-> in audition (out 0 (sinOsc AR f 0 * 0.1))
− Help/UGen/Demand/dibrown.help.lhs
@@ -1,4 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Dibrown"-> Sound.SC3.UGen.DB.ugenSummary "Dibrown"--See dbrown
− Help/UGen/Demand/diwhite.help.lhs
@@ -1,4 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Diwhite"-> Sound.SC3.UGen.DB.ugenSummary "Diwhite"--See dwhite
− Help/UGen/Demand/drand.help.lhs
@@ -1,10 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Drand"-> Sound.SC3.UGen.DB.ugenSummary "Drand"--> import Sound.SC3.ID--> let {n = drand 'α' dinf (mce [1, 3, 2, 7, 8])->     ;x = mouseX KR 1 400 Exponential 0.1->     ;t = impulse KR x 0->     ;f = demand t 0 n * 30 + 340}-> in audition (out 0 (sinOsc AR f 0 * 0.1))
− Help/UGen/Demand/dseq.help.lhs
@@ -1,36 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Dseq"-> Sound.SC3.UGen.DB.ugenSummary "Dseq"--> import Sound.SC3.ID--> let {n = dseq 'α' 3 (mce [1, 3, 2, 7, 8])->     ;x = mouseX KR 1 40 Exponential 0.1->     ;t = impulse KR x 0->     ;f = demand t 0 n * 30 + 340}-> in audition (out 0 (sinOsc AR f 0 * 0.1))--At audio rate.--> let {n = dseq 'α' dinf (mce [1,3,2,7,8,32,16,18,12,24])->     ;x = mouseX KR 1 10000 Exponential 0.1->     ;t = impulse AR x 0->     ;f = demand t 0 n * 30 + 340}-> in audition (out 0 (sinOsc AR f 0 * 0.1))--The SC2 Sequencer UGen is somewhat like the sequ function below--> let {sequ e s tr = demand tr 0 (dseq e dinf (mce s))->     ;t = impulse AR 6 0->     ;n0 = sequ 'α' [60,62,63,58,48,55] t->     ;n1 = sequ 'β' [63,60,48,62,55,58] t->     ;o = lfSaw AR (midiCPS (mce2 n0 n1)) 0 * 0.1}-> in audition (out 0 o)--Rather than MCE expansion at /tr/, it can be clearer to view /tr/ as a-functor.--> let {tr = impulse KR (mce [2,3,5]) 0->     ;f t = demand t 0 (dseq t dinf (mce [60,63,67,69]))->     ;m = mceMap f tr->     ;o = sinOsc AR (midiCPS m) 0 * 0.1}-> in audition (out 0 (splay o 1 1 0 True))
− Help/UGen/Demand/dser.help.lhs
@@ -1,10 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Dser"-> Sound.SC3.UGen.DB.ugenSummary "Dser"--> import Sound.SC3.ID--> let {a = dser 'α' 7 (mce [1, 3, 2, 7, 8])->     ;x = mouseX KR 1 40 Exponential 0.1->     ;t = impulse KR x 0->     ;f = demand t 0 a * 30 + 340}-> in audition (out 0 (sinOsc AR f 0 * 0.1))
− Help/UGen/Demand/dseries.help.lhs
@@ -1,10 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Dseries"-> Sound.SC3.UGen.DB.ugenSummary "Dseries"--> import Sound.SC3.ID--> let {n = dseries 'α' 15 0 1->     ;x = mouseX KR 1 40 Exponential 0.1->     ;t = impulse KR x 0->     ;f = demand t 0 n * 30 + 340}-> in audition (out 0 (sinOsc AR f 0 * 0.1))
− Help/UGen/Demand/dshuf.help.lhs
@@ -1,18 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Dshuf"-> Sound.SC3.UGen.DB.ugenSummary "Dshuf"--> import Sound.SC3.ID {- hsc3 -}--> let {a = dseq 'α' dinf (dshuf 'β' 3 (mce [1,3,2,7,8.5]))->     ;x = mouseX KR 1 40 Exponential 0.1->     ;t = impulse KR x 0->     ;f = demand t 0 a * 30 + 340}-> in audition (out 0 (sinOsc AR f 0 * 0.1))--> import Sound.SC3.UGen.External.RDU.ID {- sc3-rdu -}--> let {a = dseq 'α' dinf (dshuf 'β' 5 (randN 81 'γ' 0 10))->     ;x = mouseX KR 1 10000 Exponential 0.1->     ;t = impulse AR x 0->     ;f = demand t 0 a * 30 + 340}-> in audition (out 0 (sinOsc AR f 0 * 0.1))
− Help/UGen/Demand/dstutter.help.lhs
@@ -1,24 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Dstutter"-> Sound.SC3.UGen.DB.ugenSummary "Dstutter"--> import Sound.SC3.ID--> let {inp = dseq 'α' dinf (mce [1,2,3])->     ;nse = diwhite 'β' dinf 2 8->     ;rep = dstutter 'γ' nse inp->     ;trg = impulse KR (mouseX KR 1 40 Exponential 0.2) 0->     ;frq = demand trg 0 rep * 30 + 340}-> in audition (out 0 (sinOsc AR frq 0 * 0.1))--https://www.listarc.bham.ac.uk/lists/sc-users/msg14775.html--> let {a z = let {xr = dxrand z dinf (mce [0.1,0.2,0.3,0.4,0.5])->                ;lf = dstutter z 2 xr->                ;du = duty AR lf 0 DoNothing lf->                ;tr = abs (hpz1 du) >* 0->                ;ph = sweep tr (1/du)}->            in linExp ph 0 1 (rand z 50 100) (rand z 500 2000)->     ;f = mce (map a ['a'..'h'])->     ;[s0,s1] = mceChannels (splay (sinOsc AR f 0) 1 1 0 True)->     ;o = limiter (rotate2 s0 s1 (lfSaw KR 0.1 0)) 1 1e-2}-> in audition (out 0 (o * 0.25))
− Help/UGen/Demand/dswitch.help.lhs
@@ -1,27 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Dswitch"-> Sound.SC3.UGen.DB.ugenSummary "Dswitch"--> import Sound.SC3--> do {a0 <- dwhiteM 2 3 4->    ;a1 <- dwhiteM 2 0 1->    ;a2 <- dseqM 2 (mce [1,1,1,0])->    ;i <- dseqM 2 (mce [0,1,2,1,0])->    ;d <- dswitchM i (mce [a0,a1,a2])->    ;let {t = impulse KR 4 0->         ;f = demand t 0 d * 300 + 400->         ;o = sinOsc AR f 0 * 0.1}->      in audition (out 0 o)}--compare with dswitch1--> do {a0 <- dwhiteM 2 3 4->    ;a1 <- dwhiteM 2 0 1->    ;a2 <- dseqM 2 (mce [1,1,1,0])->    ;i <- dseqM 2 (mce [0,1,2,1,0])->    ;d <- dswitch1M i (mce [a0,a1,a2])->    ;let {t = impulse KR 4 0->         ;f = demand t 0 d * 300 + 400->         ;o = sinOsc AR f 0 * 0.1}->      in audition (out 0 o)}-
− Help/UGen/Demand/dswitch1.help.lhs
@@ -1,12 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Dswitch1"-> Sound.SC3.UGen.DB.ugenSummary "Dswitch1"--> import Sound.SC3.ID--> let {x = mouseX KR 0 4 Linear 0.1->     ;y = mouseY KR 1 15 Linear 0.1->     ;t = impulse KR 3 0->     ;w = dwhite 'α' dinf 20 23->     ;n = dswitch1 'β' x (mce [1, 3, y, 2, w])->     ;f = demand t 0 n * 30 + 340}-> in audition (out 0 (sinOsc AR f 0 * 0.1))
− Help/UGen/Demand/duty.help.lhs
@@ -1,17 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Duty"-> Sound.SC3.UGen.DB.ugenSummary "Duty"--> import Sound.SC3-> import qualified Sound.SC3.Monad as M--> do {n0 <- M.drand dinf (mce [0.01,0.2,0.4])->    ;n1 <- M.dseq dinf (mce [204,400,201,502,300,200])->    ;let f = duty KR n0 0 RemoveSynth n1->     in audition (out 0 (sinOsc AR (f * mce2 1 1.01) 0 * 0.1))}--Using control rate signal, mouseX, to determine duration.--> let {n = dseq 'α' dinf (mce [204,400,201,502,300,200])->     ;x = mouseX KR 0.001 2 Linear 0.1->     ;f = duty KR x 0 RemoveSynth n}-> in audition (out 0 (sinOsc AR (f * mce2 1 1.01) 0 * 0.1))
− Help/UGen/Demand/dwhite.help.lhs
@@ -1,10 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Dwhite"-> Sound.SC3.UGen.DB.ugenSummary "Dwhite"--> import Sound.SC3--> let {n = dwhite 'α' 30 0 15->     ;x = mouseX KR 1 40 Exponential 0.1->     ;t = impulse KR x 0->     ;f = demand t 0 n * 30 + 340}-> in audition (out 0 (sinOsc AR f 0 * 0.1))
− Help/UGen/Demand/dwrand.help.lhs
@@ -1,10 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Dwrand"-> Sound.SC3.UGen.DB.ugenSummary "Dwrand"--> import Sound.SC3--> let {n = dwrand 'α' dinf (mce [0.3,0.2,0.1,0.2,0.2]) (mce [1,3,2,7,8])->     ;x = mouseX KR 1 400 Exponential 0.1->     ;t = impulse KR x 0->     ;f = demand t 0 n * 30 + 340}-> in audition (out 0 (sinOsc AR f 0 * 0.1))
− Help/UGen/Demand/dxrand.help.lhs
@@ -1,33 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Dxrand"-> Sound.SC3.UGen.DB.ugenSummary "Dxrand"--> import Sound.SC3.ID--Select to draw graphs, or not...-> let drw = Sound.SC3.UGen.Dot.draw :: UGen -> IO ()-> let drw = const (return ()) :: UGen -> IO ()--> let {i = mce [0.2,0.4,dseq 'α' 2 (mce [0.1,0.1])]->     ;d = dxrand 'β' dinf i->     ;t = tDuty AR d 0 DoNothing (dwhite 'γ' dinf 0.5 1) 0}-> in audition (out 0 t) >> drw t--The list inputs to demand rate ugens may operate at different rates.-The variants i' and i'' below ought to generate the same graph.  A-simple-minded mce rule sets the rate of the operator primitive to the-maximum rate of the inputs and then does not revise this after mce-transformation, where it may be lower.  The hsc3 constructors attempt-to get this right!--> let {i = mce [0.2,0.4,dseq 'α' 2 (mce [0.1,0.1])]->     ;i' = mceMap (* 0.5) i->     ;i'' = i * 0.5->     ;d = dxrand 'β' dinf i''->     ;t = tDuty AR d 0 DoNothing (dwhite 'γ' dinf 0.5 1) 0}-> in audition (out 0 t) >> drw t--> let {n = dxrand 'α' dinf (mce [1, 3, 2, 7, 8])->     ;x = mouseX KR 1 400 Exponential 0.1->     ;t = impulse KR x 0->     ;f = demand t 0 n * 30 + 340}-> in audition (out 0 (sinOsc AR f 0 * 0.1)) >> drw f
− Help/UGen/Demand/tDuty.help.lhs
@@ -1,44 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "TDuty"-> Sound.SC3.UGen.DB.ugenSummary "TDuty"--> import Sound.SC3.ID--Play a little rhythm--> let d = dseq 'α' dinf (mce [0.1, 0.2, 0.4, 0.3])-> in audition (out 0 (tDuty AR d 0 DoNothing 1 0))--Amplitude changes--> let {d0 = dseq 'α' dinf (mce [0.1, 0.2, 0.4, 0.3])->     ;d1 = dseq 'β' dinf (mce [0.1, 0.4, 0.01, 0.5, 1.0])->     ;s = ringz (tDuty AR d0 0 DoNothing d1 1) 1000 0.1}-> in audition (out 0 s)--Mouse control.--> let {d = dseq 'α' dinf (mce [0.1, 0.4, 0.01, 0.5, 1.0])->     ;x = mouseX KR 0.003 1 Exponential 0.1->     ;s = ringz (tDuty AR x 0 DoNothing d 1) 1000 0.1 * 0.5}-> in audition (out 0 s)--Note that the 440 is the shorter pitch, since gap is set to false--> let {d0 = dser 'α' 12 (mce [0.1, 0.3])->     ;d1 = dser 'β' 12 (mce [440, 880])->     ;t = tDuty AR d0 0 RemoveSynth d1 0}-> in audition (out 0 (sinOsc AR (latch t t) 0 * 0.1))--Abstraction--> import Data.List--> let {bp n d act = let {(e,t) = unzip d->                       ;mk z l = dser z n (mce l)->                       ;sq = tDuty AR (mk 'α' t) 0 act (mk 'β' e) 0}->                   in latch sq sq->     ;bp' d = bp (genericLength d) d->     ;tm m = let f (e,t) = (e,t * m) in map f->     ;f1 = midiCPS (bp 35 (tm 0.125 [(60,1),(63,1),(67,2),(68,1),(62,1)]) RemoveSynth)->     ;f2 = midiCPS (bp' [(60,1),(63,0.5),(67,0.5),(68,1),(62,1)] DoNothing)}-> in audition (out 0 (sinOsc AR (mce2 f1 f2) 0 * 0.1))
− Help/UGen/DiskIO/diskIn.help.lhs
@@ -1,15 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "DiskIn"-> Sound.SC3.UGen.DB.ugenSummary "DiskIn"--> import Sound.SC3--> let {fn = "/home/rohan/data/audio/pf-c5.snd"->     ;nc = 1->     ;gr = out 0 (diskIn nc 0 Loop)}-> in withSC3 (do {_ <- async (b_alloc 0 65536 nc)->                ;_ <- async (b_read 0 fn 0 (-1) 0 True)->                ;play gr})--> withSC3 (do {reset->             ;_ <- async (b_close 0)->             ;async (b_free 0)})
− Help/UGen/DiskIO/diskOut.help.lhs
@@ -1,41 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "DiskOut"-> Sound.SC3.UGen.DB.ugenSummary "DiskOut"--> import Sound.OSC {- hosc -}-> import Sound.SC3.ID {- hsc3 -}--Example graph--> let gr = let d = xLine KR 20000 2 10 RemoveSynth->          in dust 'α' AR d * 0.15--> let gr = soundIn 0--Check incoming signal (either graph above or the outside world)--> audition (out 0 gr)--Record incoming signal (or above...), print some informational traces...--> let trace str = liftIO (putStrLn str)--> withSC3 (do {trace "b_alloc & b_write"->             ;_ <- async (b_alloc 0 65536 1)->             ;_ <- async (b_write 0 "/tmp/disk-out.aiff" Aiff PcmInt16 (-1) 0 True)->             ;trace "record for 10 seconds"->             ;playSynthdef 2001 (synthdef "disk-out" (diskOut 0 gr))->             ;pauseThread 10->             ;trace "stop recording and tidy up"->             ;send (n_free [2001])->             ;_ <- async (b_close 0)->             ;_ <- async (b_free 0)->             ;return ()})--Listen to recording (on loop...)--> let {fn = "/tmp/disk-out.aiff"->     ;nc = 1->     ;gr = out 0 (diskIn nc 0 Loop)}-> in withSC3 (do {_ <- async (b_alloc 0 65536 nc)->                ;_ <- async (b_read 0 fn 0 (-1) 0 True)->                ;play gr})
− Help/UGen/DiskIO/vDiskIn.help.lhs
@@ -1,16 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "VDiskIn"-> Sound.SC3.UGen.DB.ugenSummary "VDiskIn"--> import Sound.SC3 {- hsc3 -}--> let {fn = "/home/rohan/data/audio/pf-c5.snd"->     ;nc = 1->     ;gr = out 0 (vDiskIn nc 0 (sinOsc KR 0.25 0 * 0.25 + 1) Loop)}-> in withSC3 (do {_ <- async (b_alloc 0 8192 nc)->                ;_ <- async (b_read 0 fn 0 (-1) 0 True)->                ;play gr})--> withSC3 (do {reset->             ;_ <- async (b_close 0)->             ;_ <- async (b_free 0)->             ;return ()})
− Help/UGen/Envelope/detectSilence.help.lhs
@@ -1,8 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "DetectSilence"-> Sound.SC3.UGen.DB.ugenSummary "DetectSilence"--> import Sound.SC3--> let {s = sinOsc AR 440 0 * mouseY KR 0 0.2 Linear 0.1->     ;d = detectSilence s 0.1 0.1 RemoveSynth}-> in audition (mrg [out 0 s,d])
− Help/UGen/Envelope/done.help.lhs
@@ -1,10 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Done"-> Sound.SC3.UGen.DB.ugenSummary "Done"--> import Sound.SC3--> let {x = mouseX KR (-1) 1 Linear 0.1->     ;e = linen x 0.1 0.1 0.5 DoNothing->     ;o1 = sinOsc AR 880 0 * 0.1->     ;o2 = sinOsc AR 440 0 * e}-> in audition (out 0 (mce [done e * o1,o2]))
− Help/UGen/Envelope/envADSR.help.lhs
@@ -1,60 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Env.*adsr"-> :i Sound.SC3.ADSR-> :t Sound.SC3.envADSR_r-> :t Sound.SC3.envADSR--> import Sound.SC3 {- hsc3 -}--{SinOsc.ar * EnvGen.kr(Env.adsr(0.75, 2.75, 0.1, 7.25, 1, -4, 0))}.draw;--> let g = let {c = control KR "env-gate" 1->             ;p = envADSR 0.75 2.75 0.1 7.25 1 (EnvNum (-4)) 0->             ;e = envGen KR c 1 0 1 DoNothing p}->         in sinOsc AR 440 0 * e * 0.1--> audition (out 0 g)--> withSC3 (send (n_set1 (-1) "env-gate" 0))-> withSC3 (send (n_set1 (-1) "env-gate" 1))-> withSC3 (send (n_free [-1]))--> import Sound.SC3.Plot {- hsc3 -}--> plotEnvelope [envADSR 0.75 0.75 0.5 0.75 1 (EnvNum (-4)) 0->              ,envADSR 0.02 0.2 0.25 1 1 (EnvNum (-4)) 0->              ,envADSR 0.001 0.2 0.25 1 1 (EnvNum (-4)) 0->              ,envADSR 0 2 1 0.1 0.5 EnvSin 0->              ,envADSR 0.001 1.54 1 0.001 0.4 EnvSin 0]--There is a record variant:--> let {g = control KR "gate" 1->     ;c = EnvNum (-4)->     ;r = ADSR {adsr_attackTime = 0.75->               ,adsr_decayTime = 0.75->               ,adsr_sustainLevel = 0.5->               ,adsr_releaseTime = 0.75->               ,adsr_peakLevel = 1->               ,adsr_curve = (c,c,c)->               ,adsr_bias = 0}->     ;p = envADSR_r r->     ;e = envGen KR g 0.1 0 1 DoNothing p}-> in audition (out 0 (sinOsc AR 440 0 * e))--> withSC3 (send (n_set1 (-1) "gate" 0))-> withSC3 (send (n_set1 (-1) "gate" 1))-> withSC3 (send (n_free [-1]))--SC3 comparison:--Env.adsr.asArray == [0,3,2,-99,1,0.01,5,-4,0.5,0.3,5,-4,0,1,5,-4];--> let r = [0,3,2,-99,1,0.01,5,-4,0.5,0.3,5,-4,0,1,5,-4]-> in envelope_sc3_array (envADSR 0.01 0.3 0.5 1 1 (EnvNum (-4)) 0) == Just r--> let r = [0,3,2,-99,1,0.3,5,-4,0.1,0.4,5,-4,0,1.2,5,-4]-> in envelope_sc3_array (envADSR 0.3 0.4 0.1 1.2 1 (EnvNum (-4)) 0) == Just r--x = {|gate=0, freq=440 | EnvGen.kr(Env.adsr,gate) * SinOsc.ar(freq,0) * 0.1}.play-x.set(\gate,1);-x.set(\gate,0);
− Help/UGen/Envelope/envASR.help.lhs
@@ -1,17 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Env.*asr"-> :i Sound.SC3.ASR--> import Sound.SC3--> let {g = control KR "env-gate" 1->     ;p = envASR 0.01 1 1 (EnvNum (-4))->     ;e = envGen KR g 0.1 0 1 RemoveSynth p}-> in audition (out 0 (sinOsc AR 440 0 * e))--> withSC3 (send (n_set1 (-1) "env-gate" 0))--> import Sound.SC3.Plot--> plotEnvelope [envASR 0.1 1 1 (EnvNum (-4))->              ,envASR 0.3 0.25 1 EnvSin->              ,envASR 0.01 0.5 1.25 EnvLin]
− Help/UGen/Envelope/envCoord.help.lhs
@@ -1,48 +0,0 @@-> import Sound.SC3-> :t envCoord--co-ordinate (break-point) envelope--> let {c = EnvLin->     ;p = envCoord [(0,0),(0.5,0.1),(0.55,1),(1,0)] 9 0.1 c->     ;e = envGen KR 1 1 0 1 RemoveSynth p}-> in audition (out 0 (sinOsc AR 440 0 * e))--line segments, set target value & transition time and trigger--> let {tr = tr_control "tr" 1->     ;st = control KR "st" 440->     ;en = control KR "en" 880->     ;tm = control KR "tm" 2->     ;p = envCoord [(0,st),(tm,en)] 1 1 EnvLin->     ;e = envGen KR tr 1 0 1 DoNothing p}-> in audition (out 0 (sinOsc AR e 0 * 0.2))--> withSC3 (send (n_set (-1) [("en",550),("tm",4),("tr",1)]))-> withSC3 (send (n_set (-1) [("en",990),("tm",1),("tr",1)]))-> withSC3 (send (n_set (-1) [("en",110),("tm",2),("tr",1)]))--> import Sound.SC3.ID--likewise, but internal graph triggers and randomises line end points--> let {tr = dust 'α' KR 2->     ;st = 440->     ;en = tRand 'β' 300 900 tr->     ;tm = tRand 'γ' 0.5 1.5 tr->     ;p = envCoord [(0,st),(tm,en)] 1 1 EnvLin->     ;e = envGen KR tr 1 0 1 DoNothing p}-> in audition (out 0 (sinOsc AR e 0 * 0.2))--plotting--> import Sound.SC3.Plot--> let {c0 = [(0,0),(0.35,0.1),(0.55,1),(1,0)]->     ;c1 = [(0,0),(0.15,0.6),(0.35,0.2),(1,0)]->     ;c2 = [(0,0),(0.65,0.3),(0.85,0.7),(1,0)]->     ;c3 = [(0,0.1),(0.25,0.6),(0.5,0.4),(1,0.4)]}-> in plotEnvelope [envCoord c0 9 0.1 EnvLin->                 ,envCoord c1 6 0.1 EnvSin->                 ,envCoord c2 5 0.1 EnvCub->                 ,envCoord c3 7 0.1 EnvStep]
− Help/UGen/Envelope/envGate.help.lhs
@@ -1,30 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "EnvGate"--> import Sound.SC3--Make envGate, giving the /default/ arguments, as used by envGate'.--> let {k = control KR->     ;e = envGate 1 (k "gate" 1) (k "fadeTime" 0.02) RemoveSynth EnvSin}-> in audition (out 0 (lpf (saw AR 200) 600 * 0.1 * e))--Set fade time, then release gate.--> withSC3 (send (n_set1 (-1) "fadeTime" 2))-> withSC3 (send (n_set1 (-1) "gate" 0))--The same, but built in defaults.--> let e = envGate'-> in audition (out 0 (lpf (saw AR 200) 600 * 0.1 * e))--Several envGate nodes can coexist in one synth, but if they are the-same they're shared (as ever).--> let {e = envGate'->     ;s1 = lpf (saw AR 80) 600 * e->     ;s2 = rlpf (saw AR 200 * 0.5) (6000 * e + 60) 0.1 * e}-> in audition (out 0 (mce2 s1 s2 * 0.1))--> withSC3 (send (n_set1 (-1) "fadeTime" 5))-> withSC3 (send (n_set1 (-1) "gate" 0))
− Help/UGen/Envelope/envGen.help.lhs
@@ -1,33 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "EnvGen"-> Sound.SC3.UGen.DB.ugenSummary "EnvGen"--At least the following envelope constructors are provided:-envPerc, envSine, envCoord, envTrapezoid, and envLinen.--> import Sound.SC3 {- hsc3 -}--env_circle joins the end of the envelope to the start--> let {e = Envelope [6000,700,100] [1,1] [EnvExp,EnvLin] Nothing Nothing->     ;f = envGen KR 1 1 0 1 DoNothing (env_circle e 0 EnvLin)->     ;o = sinOsc AR f 0 * 0.1 + impulse AR 1 0}-> in audition (out 0 o)--Env([6000,700,100],[1,1],['exp','lin']).circle.asArray--> let {e = Envelope [6000,700,100] [1,1] [EnvExp,EnvLin] Nothing Nothing->     ;r = [0,4,3,0,6000,0,1,0,700,1,2,0,100,1,1,0,0,9e8,1,0]}-> in envelope_sc3_array (env_circle e 0 EnvLin) == Just r--Env([0,1],[0.1]).asArray == [0,1,-99,-99,1,0.1,1,0]--> let e = (Envelope [0,1] [0.1] [EnvLin] Nothing Nothing)-> in envelope_sc3_array e == Just [0,1,-99,-99,1,0.1,1,0]--https://www.listarc.bham.ac.uk/lists/sc-users/msg14815.html--> let {n = range 0.01 0.1 (lfNoise1 'α' KR 2)->     ;e = Envelope [0,1] [n] [EnvLin] Nothing (Just 0)->     ;a = envGen AR 1 1 0 1 DoNothing (env_circle e 0 EnvLin)->     ;o = sinOsc AR (a * 400 + 500) 0 * 0.1}-> in audition (out 0 o)
− Help/UGen/Envelope/envLinen.help.lhs
@@ -1,26 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Env.*linen"-> :i Sound.SC3.LINEN-> :t envLinen--> import Sound.SC3--> let {t = envLinen 0.4 2 0.4 0.1->     ;e = envGen KR 1 1 0 1 RemoveSynth t}-> in audition (out 0 (sinOsc AR 440 0 * e))--> import Sound.SC3.Plot--> plotEnvelope [envLinen 0 1 0 0.4->              ,envelope_normalise (envLinen 0 2 0 0.5)->              ,envLinen 0.4 2 0.4 0.6->              ,envLinen 0.6 1 1.2 0.7]--> let e = envLinen 0 1 0 1-> in (envelope_duration e->    ,envelope_segment_ix e 0->    ,envelope_segment_ix e 1->    ,envelope_segment e 0->    ,envelope_segment e 1->    ,envelope_at e 0->    ,envelope_at e 1->    ,envelope_render 10 e)
− Help/UGen/Envelope/envPerc.help.lhs
@@ -1,19 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Env.*perc"-> :t envPerc'--> import Sound.SC3 {- hsc3 -}--> let {a = 0.1->     ;p = envPerc 0.01 1->     ;e = envGen KR 1 a 0 1 RemoveSynth p }-> in audition (out 0 (sinOsc AR 440 0 * e))--> let {a = 0.1->     ;c = EnvNum (-4)->     ;p = envPerc' 0.01 1 a (c,c)->     ;e = envGen KR 1 1 0 1 RemoveSynth p }-> in audition (out 0 (sinOsc AR 440 0 * e))--> import Sound.SC3.Plot {- hsc3-plot -}--> plotEnvelope [envPerc 0.05 1,envPerc 0.2 0.75]
− Help/UGen/Envelope/envSine.help.lhs
@@ -1,12 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Env.*sine"-> :t Sound.SC3.envSine--> import Sound.SC3 {- hsc3 -}--> let {s = envSine 9 0.1->     ;e = envGen KR 1 1 0 1 RemoveSynth s}-> in audition (out 0 (sinOsc AR 440 0 * e))--> import Sound.SC3.Plot {- hsc3-plot -}--> plotEnvelope [envSine 9 1,envSine 3 0.25]
− Help/UGen/Envelope/envStep.help.lhs
@@ -1,22 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Env.*step"-> :i Sound.SC3.envStep--> import Sound.SC3 {- hsc3 -}--> let {env = envStep [0.0,0.5,0.7,1.0,0.9,0.0] [0.5,0.1,0.2,1.0,1.5,3] Nothing Nothing->     ;envgen = envGen AR 1 1 0 1 RemoveSynth env->     ;o = sinOsc AR (envgen * 1000 + 440) 0 * (envgen + 1) * 0.1}-> in audition (out 0 o)--major scale, accelerating--> let {env = envStep [0,2,4,5,7,9,11,12] (take 8 (iterate (* 0.75) 1)) Nothing Nothing->     ;envgen = envGen AR 1 1 0 1 DoNothing env->     ;o = sinOsc AR (midiCPS (envgen + 60)) 0 * 0.1}-> in audition (out 0 o)--draw envelope--> import Sound.SC3.Plot--> plotEnvelope [envStep [0,2,4,5,7,9,11,12] (take 8 (iterate (* 0.75) 1)) Nothing Nothing]
− Help/UGen/Envelope/envTrapezoid.help.lhs
@@ -1,13 +0,0 @@-> :t Sound.SC3.envTrapezoid--> import Sound.SC3--> let { t = envTrapezoid 0.05 0.95 3 0.1->     ; e = envGen KR 1 1 0 1 RemoveSynth t }-> in audition (out 0 (sinOsc AR 440 0 * e))--> let e = [0,3,-99,-99,0.1,0.5,1,0,0.1,0,1,0,0,1.5,1,0]-> in envelope_sc3_array (envTrapezoid 0 0.25 2 0.1) == Just e--> import Sound.SC3.Plot-> plotEnvelope [envTrapezoid 0.75 0.25 2 1,envTrapezoid 0.25 0.75 3 0.5]
− Help/UGen/Envelope/envTriangle.help.lhs
@@ -1,11 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Env.*triangle"-> :t envTriangle--> import Sound.SC3--> let {t = envTriangle 1 0.1->     ;e = envGen KR 1 1 0 1 RemoveSynth t}-> in audition (out 0 (sinOsc AR 440 0 * e))--> import Sound.SC3.Plot-> plotEnvelope [envTriangle 1 1,envTriangle 0.25 0.5]
− Help/UGen/Envelope/free.help.lhs
@@ -1,13 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Free"-> Sound.SC3.UGen.DB.ugenSummary "Free"--> import Sound.SC3.ID--> let {a = out 0 (sinOsc AR 880 0 * 0.1)->     ;n0 = pinkNoise 'a' AR->     ;n1 = dust 'b' AR 20->     ;b = mrg [out 1 (n0 * 0.1), free n1 1001]}-> in withSC3 (do {_ <- async (d_recv (synthdef "a" a))->                ;_ <- async (d_recv (synthdef "b" b))->                ;send (s_new "a" 1001 AddToTail 1 [])->                ;send (s_new "b" (-1) AddToTail 1 [])})
− Help/UGen/Envelope/freeSelf.help.lhs
@@ -1,9 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "FreeSelf"-> Sound.SC3.UGen.DB.ugenSummary "FreeSelf"--> import Sound.SC3.ID--> let {n = dust 'a' KR 0.5->     ;a = freeSelf n->     ;b = out 0 (sinOsc AR 440 0 * 0.1)}-> in audition (mrg [a,b])
− Help/UGen/Envelope/freeSelfWhenDone.help.lhs
@@ -1,14 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "FreeSelfWhenDone"-> Sound.SC3.UGen.DB.ugenSummary "FreeSelfWhenDone"--> import Sound.SC3--using RemoveSynth doneAction-> let {x = mouseX KR (-1) 1 Linear 0.1->     ;e = linen x 1 0.1 1 RemoveSynth}-> in audition (out 0 (sinOsc AR 440 0 * e))--using FreeSelfWhenDone UGen-> let {x = mouseX KR (-1) 1 Linear 0.1->     ;e = linen x 1 0.1 1 DoNothing}-> in audition (mrg [freeSelfWhenDone e, out 0 (sinOsc AR 440 0 * e)])
− Help/UGen/Envelope/iEnvGen.help.lhs
@@ -1,25 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "IEnvGen"-> Sound.SC3.UGen.DB.ugenSummary "IEnvGen"--> import Sound.SC3.ID--> let {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->     ;x = mouseX KR 0 (sum t) Linear 0.2->     ;g = iEnvGen KR x e->     ;o = sinOsc AR (g * 500 + 440) 0 * 0.1}-> in audition (out 0 o)--index with an SinOsc ... mouse controls amplitude of SinOsc-use offset so negative values of SinOsc will map into the Env--> let {l = [-1,-0.7,0.7,1]->     ;t = [0.8666,0.2666,0.8668]->     ;c = [EnvLin,EnvLin]->     ;e = Envelope l t c Nothing Nothing->     ;x = mouseX KR 0 1 Linear 0.2->     ;o = (sinOsc AR 440 0 + 1) * x->     ;g = iEnvGen AR o e * 0.1}-> in audition (out 0 g)
− Help/UGen/Envelope/line.help.lhs
@@ -1,16 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Line"-> Sound.SC3.UGen.DB.ugenSummary "Line"--#SC3 reorders the mul and add inputs to precede the doneAction input.--> import Sound.SC3--> let f = line KR 200 17000 5 RemoveSynth-> in audition (out 0 (sinOsc AR f 0 * 0.1))--Demonstrate RemoveGroup done-action.--> withSC3 (send (g_new [(10,AddToTail,1)]))--> let f = line KR 200 (mce2 209 211) 5 RemoveGroup-> in audition_at (-1,AddToTail,10) (out 0 (sinOsc AR f 0 * 0.1))
− Help/UGen/Envelope/linen.help.lhs
@@ -1,12 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Linen"-> Sound.SC3.UGen.DB.ugenSummary "Linen"--> import Sound.SC3--> let e = linen (impulse KR 2 0) 0.01 0.6 0.4 DoNothing-> in audition (out 0 (e * sinOsc AR 440 0 * 0.1))--> let {x = mouseX KR (-1) 1 Linear 0.1->     ;y = mouseY KR 0.1 0.5 Linear 0.1->     ;e = linen x 1 y 1.0 DoNothing}-> in audition (out 0 (sinOsc AR 440 0 * e))
− Help/UGen/Envelope/pause.help.lhs
@@ -1,18 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Pause"-> Sound.SC3.UGen.DB.ugenSummary "Pause"--> import Sound.SC3--> let {f = control KR "f" 440->     ;g = control KR "g" 1->     ;a = mrg [out 0 (sinOsc AR f 0 * 0.1),pause g 1001]->     ;a' = synthdef "a" a}-> in withSC3 (do {_ <- async (d_recv a')->                ;send (s_new "a" 1001 AddToTail 1 [])->                ;send (s_new "a" 1002 AddToTail 1 [("f",880)])})--Request that node 1002 pause node 1001.-> withSC3 (send (n_set 1002 [("g",0)]))--Restart node 1001.-> withSC3 (send (n_set 1002 [("g",1)]))
− Help/UGen/Envelope/pauseSelf.help.lhs
@@ -1,11 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "PauseSelf"-> Sound.SC3.UGen.DB.ugenSummary "PauseSelf"--> import Sound.SC3--> let {x = mouseX KR (-1) 1 Linear 0.1->     ;o = sinOsc AR 440 0 * 0.1}-> in audition (mrg [pauseSelf x, out 0 o])--Run paused node (assuming no intermediate node is created).-> withSC3 (send (n_run [(-1, True)]))
− Help/UGen/Envelope/pauseSelfWhenDone.help.lhs
@@ -1,19 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "PauseSelfWhenDone"-> Sound.SC3.UGen.DB.ugenSummary "PauseSelfWhenDone"--> import Sound.SC3--using PauseSynth done action-> let { x = mouseX KR (-1) 1 Linear 0.1->     ; e = linen x 1 0.1 1 PauseSynth }-> in audition (out 0 (sinOsc AR 440 0 * e))--Run paused node (assuming no intermediate node is created).-> withSC3 (send (n_run [(-1, True)]))--> let {x = mouseX KR (-1) 1 Linear 0.1->     ;e = linen x 1 0.1 1 DoNothing->     ;o = sinOsc AR 440 0 * e}-> in audition (mrg [pauseSelfWhenDone e, out 0 o])--> withSC3 (send (n_run [(-1, True)]))
− Help/UGen/Envelope/xLine.help.lhs
@@ -1,10 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "XLine"-> Sound.SC3.UGen.DB.ugenSummary "XLine"--# SC3 reorders mul and add inputs to precede the doneAction input.--> import Sound.SC3--> let {f = xLine KR 200 17000 10 RemoveSynth->     ;o = sinOsc AR f 0 * 0.1}-> in audition (out 0 o)
− Help/UGen/External/atari2600.help.lhs
@@ -1,68 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Atari2600"-> Sound.SC3.UGen.DB.ugenSummary "Atari2600"--> import Sound.SC3 {- hsc3 -}--> audition (out 0 (atari2600 1 2 3 4 5 5 1))-> audition (out 0 (atari2600 2 3 10 10 5 5 1))--> let {x = mouseX KR 0 15 Linear 0.1->     ;y = mouseY KR 0 15 Linear 0.1}-> in audition (out 0 (atari2600 x y 10 10 5 5 1))--> let {x = mouseX KR 0 31 Linear 0.1->     ;y = mouseY KR 0 31 Linear 0.1}-> in audition (out 0 (atari2600 2 3 x y 5 5 1))--> let {x = mouseX KR 0 15 Linear 0.1->     ;y = mouseY KR 0 15 Linear 0.1}-> in audition (out 0 (atari2600 2 3 10 10 x y 1))--> let {x = mouseX KR 0 15 Linear 0.1->     ;o1 = sinOsc KR 0.35 0 * 7.5 + 7.5->     ;y = mouseY KR 0 31 Linear 0.1->     ;o2 = sinOsc KR 0.3 0 * 5.5 + 5.5}-> in audition (out 0 (atari2600 x o1 10 y o2 5 1))--> let ati = let {gate' = control KR "gate" 1->               ;tone0 = control KR "tone0" 5->               ;tone1 = control KR "tone1" 8->               ;freq0 = control KR "freq0" 10->               ;freq1 = control KR "freq1" 20->               ;rate = control KR "rate" 1->               ;amp = control KR "amp" 1->               ;pan = control KR "pan" 0->               ;e = envASR 0.01 amp 0.05 (EnvNum (-4))->               ;eg = envGen KR gate' 1 0 1 RemoveSynth e->               ;z = atari2600 tone0 tone1 freq0 freq1 15 15 rate->               ;o = out 0 (pan2 (z * eg) pan 1)}->           in synthdef "atari2600" o--> import Sound.SC3.Lang.Pattern--> let p = [(K_instr,psynth ati)->         ,(K_dur,0.125)->         ,(K_amp,0.5)->         ,(K_param "tone0",pseq [pn 3 64,pn 2 128,pn 10 8] inf)->         ,(K_param "tone1",pseqn [32,12] [8,pwhite 'α' 0 15 inf] inf)->         ,(K_param "freq0",pseqn [17,4,3] [10,prand 'β' [1,2,3] inf,10] inf)->         ,(K_param "freq1",pseq1 [10,3,pwrand 'γ' [20,1] [0.6,0.4] inf] inf)]-> in audition (pbind p)--> let p = [(K_instr,psynth ati)->         ,(K_dur,pseq [0.25,0.25,0.25,0.45] inf)->         ,(K_amp,0.5)->         ,(K_param "tone0",pseq [pseq [2,5] 32,pseq [3,5] 32] inf)->         ,(K_param "tone1",14)->         ,(K_param "freq0",pseq [pbrown 'α' 28 31 1 32,pbrown 'β' 23 26 3 32] inf)->         ,(K_param "freq1",pseq [pn 10 16,pn 11 16] inf)]-> in audition (pbind p)--> let p = [(K_instr,psynth ati)->         ,(K_dur,pbrown 'α' 0.1 0.15 0.1 inf)->         ,(K_amp,0.5)->         ,(K_param "tone0",1)->         ,(K_param "tone1",2)->         ,(K_param "freq0",pseqn [2,1] [24,pwrand 'β' [20,23] [0.6,0.4] inf] inf)->         ,(K_param "freq1",pseqn [1,1,1] [1,3,pwrand 'γ' [2,1] [0.6,0.4] inf] inf)]-> in audition (pbind p)
− Help/UGen/External/atsNoiSynth.help.lhs
@@ -1,27 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "AtsNoiSynth"-> Sound.SC3.UGen.DB.ugenSummary "AtsNoiSynth"--> import Sound.SC3--segmented file loader-> let load_data b i d =->         if length d < 512->         then send (b_setn1 b i d)->         else do {send (b_setn1 b i (take 512 d))->                 ;load_data b (i + 512) (drop 512 d)}--read file-> ats <- atsRead "/home/rohan/cvs/tn/tn-56/ats/metal.ats"--run re-synthesis-> let {d = atsData ats->     ;h = atsHeader ats->     ;x = mouseX KR 0.05 1.5 Linear 0.2->     ;y = mouseY KR 0 1 Linear 0.2->     ;np = constant (atsNPartials h)->     ;f = x / constant (atsAnalysisDuration h)->     ;ptr = clip (lfSaw AR f 1 * 0.5 + 0.5) 0 1->     ;rs = atsNoiSynth 10 np 0 1 ptr (1 - y) y 1 0 25 0 1}-> in withSC3 (do {_ <- async (b_alloc 10 (length d) 1)->                ;load_data 10 0 d->                ;play (out 0 rs)})
− Help/UGen/External/atsSynth.help.lhs
@@ -1,30 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "AtsSynth"-> Sound.SC3.UGen.DB.ugenSummary "AtsSynth"--> import Sound.SC3--read file-> ats <- atsRead "/home/rohan/cvs/tn/tn-56/ats/metal.ats"--show header-> atsHeader ats--data loader that works in segments (udp packet limits)-> let load_data b i d =->         if length d < 512->         then send (b_setn1 b i d)->         else do {send (b_setn1 b i (take 512 d))->                 ;load_data b (i + 512) (drop 512 d)}--simple re-synthesiser-> let {h = atsHeader ats->     ;d = atsData ats->     ;x = mouseX KR 0.05 1.5 Linear 0.2->     ;y = mouseY KR 0.25 2.0 Linear 0.2->     ;np = constant (atsNPartials h)->     ;f = x / constant (atsAnalysisDuration h)->     ;ptr = lfSaw AR f 1 * 0.5 + 0.5->     ;rs = atsSynth 10 np 0 1 (clip ptr 0 1) y 0}-> in withSC3 (do {_ <- async (b_alloc 10 (length d) 1)->                ;load_data 10 0 d->                ;play (out 0 rs)})
− Help/UGen/External/ay.help.lhs
@@ -1,33 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "AY"-> Sound.SC3.UGen.DB.ugenSummary "AY"--> import Sound.SC3.ID-> import qualified Sound.SC3.Monad as M--> audition (out 0 (ay 1777 1666 1555 1 7 15 15 15 4 1 0))--> let { tonea = mouseY KR 10 3900 Exponential 0.2->     ; toneb = mouseX KR 10 3900 Exponential 0.2->     ; ctl = 3->     ; vola = 14->     ; volb = 14->     ; volc = 0->     ; s = ay tonea toneb 1555 1 ctl vola volb volc 4 1 0 }-> in audition (out 0 (pan2 s 0 0.25))--> let {rate = mouseX KR 0.1 10 Linear 0.2->     ;rng l r i = return (linLin i (-1) 1 l r)->     ;mk_ctl l r = M.lfdNoise3 KR rate >>= rng l r->     ;mk_ctl_0 l r = M.lfdNoise0 KR rate >>= rng l r}-> in do {tonea <- mk_ctl 10 3900->       ;toneb <- mk_ctl 10 3900->       ;tonec <- mk_ctl 10 3900->       ;n <- mk_ctl 0 31->       ;ctl <- mk_ctl_0 0 31->       ;vola <- mk_ctl 0 15->       ;volb <- mk_ctl 0 15->       ;volc <- mk_ctl 0 15->       ;efreq <- mk_ctl 0 4095->       ;estyle <- mk_ctl 0 15->       ;let s = ay tonea toneb tonec n ctl vola volb volc efreq estyle 0->        in audition (out 0 (pan2 s 0 0.5))}
− Help/UGen/External/concat.help.lhs
@@ -1,20 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Concat"-> Sound.SC3.UGen.DB.ugenSummary "Concat"--> import Sound.SC3.ID--> let fileName = "/home/rohan/data/audio/pf-c5.snd"-> in withSC3 (async (b_allocRead 12 fileName 0 0))--Granulator-> let {y0 = mouseY KR 0.01 1 Linear 0.2->     ;y1 = mouseY KR 12 100 Linear 0.2->     ;n = lfNoise0 'α' KR y0 * 3 + 4.5->     ;k = saw AR (sinOsc KR n 0 * 10 + y1)->     ;i = playBuf 1 AR 12 (bufRateScale KR 12) 0 0 Loop DoNothing->     ;x0 = mouseX KR 0.01 0.1 Linear 0.2->     ;y2 = mouseY KR 0 0.1 Linear 0.2->     ;c :: UGen->     ;c = concat' k i 2 2 2 x0 0 y2 1 0.5 0 0->     ;o = out 0 (pan2 c 0 1)}-> in audition o
− Help/UGen/External/coyote.help.lhs
@@ -1,9 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Coyote"-> Sound.SC3.UGen.DB.ugenSummary "Coyote"--> import Sound.SC3.ID--> let {i = soundIn 4->     ;c = coyote KR i 0.2 0.2 0.01 0.5 0.05 0.05->     ;o = pinkNoise 'a' AR * decay c 1}-> in audition (out 0 (mce2 i o))
− Help/UGen/External/dPW3Tri.help.lhs
@@ -1,42 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "DPW3Tri"-> Sound.SC3.UGen.DB.ugenSummary "DPW3Tri"--> import Sound.SC3.ID--distortion creeps in under 200Hz-> let o = dPW3Tri AR (xLine KR 2000 20 10 DoNothing)-> in audition (out 0 (o * 0.1))--very fast sweeps can have transient distortion effects-> let o = dPW3Tri AR (mouseX KR 200 12000 Exponential 0.2)-> in audition (out 0 (o * 0.1))--compare-> let o = lfTri AR (mouseX KR 200 12000 Exponential 0.2) 0-> in audition (out 0 (o * 0.1))--(for randN)-> import Sound.SC3.UGen.External.RDU.ID--less efficient than LFTri-> let f = randN 50 'a' 50 5000-> in audition (out 0 (splay (dPW3Tri AR f) 1 0.1 0 True))--> let f = randN 50 'a' 50 5000-> in audition (out 0 (splay (lfTri AR f 0) 1 0.1 0 True))--triangle is integration of square wave-> let {f = mouseX KR 440 8800 Exponential 0.2->     ;o = pulse AR f 0.5->     ;s = integrator o 0.99}-> in audition (out 0 (s * 0.05))--differentiation of triangle is square-> let {f = mouseX KR 440 8800 Exponential 0.2->     ;o = dPW3Tri AR f->     ;s = hpz1 (o * 2)}-> in audition (out 0 (s * 0.25))--compare-> let f = mouseX KR 440 8800 Exponential 0.2-> in audition (out 0 (pulse AR f 0.5 * 0.1))
− Help/UGen/External/dWGPlucked2.help.lhs
@@ -1,37 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "DWGPlucked2"-> Sound.SC3.UGen.DB.ugenSummary "DWGPlucked2"--> import Sound.SC3.ID--self deleting-> let {amp = 0.5->     ;gate = 1->     ;freq = 440->     ;c3 = 20->     ;pan = 0->     ;e = Envelope->      [0,1,1,0] [0.001,0.006,0.0005]->      (map EnvNum [5,-5,-8]) Nothing Nothing->     ;i = amp * lfClipNoise 'α' AR 2000 * envGen AR gate 1 0 1 DoNothing e->     ;s = dWGPlucked2 AR freq amp gate 0.1 1 c3 i 0.1 1.008 0.55 0.01->     ;z = detectSilence s 0.001 0.1 RemoveSynth}-> in audition (out 0 (mrg2 (pan2 s pan 0.1) z))--re-sounding-> let {sequ e s tr = demand tr 0 (dseq e dinf (mce s))->     ;d = dseq 'α' dinf (mce [1,1,2,1,1,1,2,3,1,1,1,1,2,3,4] * 0.175)->     ;t = tDuty AR d 0 DoNothing 1 0->     ;amp = tRand 'β' 0.01 0.25 t->     ;n0 = sequ 'γ' [60,62,63,58,48,55] t->     ;n1 = sequ 'δ' [63,60,48,62,55,58] t->     ;freq = midiCPS (mce2 n0 n1)->     ;c3 = tRand 'ε' 300 1400 t->     ;pan = tRand 'ζ' (-1) 1 t->     ;e_dt = tRand 'η' 0.05 0.150 t->     ;mt = tRand 'θ' 0.992 1.008 t->     ;pp = tRand 'ι' 0.05 0.15 t->     ;dt = tRand 'κ' 0.25 1.75 t->     ;env = decay2 t 0.001 e_dt * lfClipNoise 'λ' AR 2000->     ;i = amp * lfClipNoise 'μ' AR 2000 * env->     ;ps = dWGPlucked2 AR freq amp 1 pp (1 / dt) c3 i 0.1 mt 0.55 0.01}-> in audition (out 0 (pan2 ps pan 0.1))
− Help/UGen/External/dfm1.help.lhs
@@ -1,18 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "DFM1"-> Sound.SC3.UGen.DB.ugenSummary "DFM1"--> import Sound.SC3.ID--Play it with the mouse--> let { n = pinkNoise 'α' AR * 0.5->     ; x = mouseX KR 80 5000 Exponential 0.1->     ; y = mouseX KR 0.1 1.2 Linear 0.1 }-> in audition (out 0 (dfm1 n x y 1 0 3e-4))--Bass...--> let { i = pulse AR 100 0.5 * 0.4 + pulse AR 100.1 0.5 * 0.4->     ; f = range 80 2000 (sinOsc KR (range 0.2 5 (sinOsc KR 0.3 0)) 0)->     ; s = dfm1 i f 1.1 2 0 3e-4 * 0.1 }-> in audition (out 0 (mce2 s s))
− Help/UGen/External/disintegrator.help.lhs
@@ -1,10 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Disintegrator"-> Sound.SC3.UGen.DB.ugenSummary "Disintegrator"--> import Sound.SC3--> let {x = mouseX KR 0 1 Linear 0.2->     ;y = mouseY KR 0 1 Linear 0.2->     ;s = sinOsc AR (mce2 400 404) 0 * 0.2->     ;o = disintegrator 'α' s x y}-> in audition (out 0 o)
− Help/UGen/External/envDetect.help.lhs
@@ -1,12 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "EnvDetect"-> Sound.SC3.UGen.DB.ugenSummary "EnvDetect"--> import Sound.SC3.ID--> let {i = soundIn 4->     ;c = envDetect AR i 0.01 0.1->     ;p = pitch i 440 60 4000 100 16 1 0.01 0.5 1 0->     ;f = mceChannel 0 p * 3->     ;e = lagUD (mceChannel 1 p) 0 0.1->     ;o = pinkNoise 'α' AR * c + sinOsc AR f 0 * c * e}-> in audition (out 0 (mce2 i o))
− Help/UGen/External/envFollow.help.lhs
@@ -1,10 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "EnvFollow"-> Sound.SC3.UGen.DB.ugenSummary "EnvFollow"--> import Sound.SC3.ID--> let {z = soundIn 4->     ;d = mouseX KR 0.990 0.999 Linear 0.2->     ;c = envFollow KR z d->     ;o = pinkNoise 'α' AR * c}-> in audition (out 0 (mce2 z o))
− Help/UGen/External/fm7.help.lhs
@@ -1,81 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "FM7"-> Sound.SC3.UGen.DB.ugenSummary "FM7"--> import Sound.SC3--> let {c = [[xLine KR 300 310 4 DoNothing,0,1]->          ,[xLine KR 300 310 8 DoNothing,0,1]->          ,[0,0,1]->          ,[0,0,1]->          ,[0,0,1]->          ,[0,0,1] ]->     ;m = [[line KR 0 0.001 2 DoNothing,line KR 0.1 0 4 DoNothing,0,0,0,0]->          ,[line KR 0 6 1 DoNothing,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] ]->     ;[l,r,_,_,_,_] = mceChannels (fm7 c m)}-> in audition (out 0 (mce2 l r * 0.1))--An algorithmically generated graph courtesy f0.-> let { x = [[[0.0,-1/3,-1.0,0.0]->            ,[0.75,0.75,0.0,-0.5]->            ,[-0.5,-0.25,0.25,-0.75]->            ,[-0.5,1.0,1.0,1.0]->            ,[0.0,1/6,-0.75,-1.0]->            ,[0.5,0.5,-0.5,1/3]]->           ,[[-1/3,0.5,-0.5,-0.5]->            ,[0.5,0.75,0.25,0.75]->            ,[-15/18,0.25,-1.0,0.5]->            ,[1.5,0.25,0.25,-0.25]->            ,[-2/3,-2/3,-1.0,-0.5]->            ,[-1.0,0.0,-15/18,-1/3]]->           ,[[0.25,-0.5,-0.5,-1.0]->            ,[-0.5,1.0,-1.5,0.0]->            ,[-1.0,-1.5,-0.5,0.0]->            ,[0.5,-1.0,7/6,-0.5]->            ,[15/18,-0.75,-1.5,0.5]->            ,[0.25,-1.0,0.5,1.0]]->           ,[[1.0,1/3,0.0,-0.75]->            ,[-0.25,0.0,0.0,-0.5]->            ,[-0.5,-0.5,0.0,0.5]->            ,[1.0,0.75,0.5,0.5]->            ,[0.0,1.5,-0.5,0.0]->            ,[1.0,0.0,-0.25,-0.5]]->           ,[[0.5,-0.25,0.0,1/3]->            ,[0.25,-0.75,1/3,-1.0]->            ,[-0.25,-0.5,0.25,-7/6]->            ,[0.0,0.25,0.5,1/6]->            ,[-1.0,-0.5,15/18,-0.5]->            ,[15/18,-0.75,-0.5,0.0]]->           ,[[0.0,-0.75,-1/6,0.0]->            ,[1.0,0.5,0.5,0.0]->            ,[-0.5,0.0,-0.5,0.0]->            ,[-0.5,-1/6,0.0,0.5]->            ,[-0.25,1/6,-0.75,0.25]->            ,[-7/6,-4/3,-1/6,1.5]]]->     ; y = [[[0.0,-0.5,1.0,0.0]->            ,[-0.5,1.0,0.5,-0.5]->            ,[0.0,1/3,1.0,1.0]]->           ,[[-0.5,0.5,1.0,1.0]->            ,[0.0,1/3,0.0,1.5]->            ,[-0.5,15/18,1.0,0.0]]->           ,[[0.25,-2/3,0.25,0.0]->            ,[0.5,-0.5,-0.5,-0.5]->            ,[0.5,-0.5,-0.75,15/18]]->           ,[[-0.25,1.0,0.0,1/3]->            ,[-1.25,-0.25,0.5,0.0]->            ,[0.0,-1.25,-0.25,-0.5]]->           ,[[0.75,-0.25,1.5,0.0]->            ,[0.25,-1.5,0.5,0.5]->            ,[-0.5,-0.5,-0.5,-0.25]]->           ,[[0.0,0.5,-0.5,0.25]->            ,[0.25,0.5,-1/3,0.0]->            ,[1.0,0.5,-1/6,0.5]]]->     ; cs = map (map (\[f,p,m,a] -> sinOsc AR f p * m + a)) x->     ; ms = map (map (\[f,w,m,a] -> pulse AR f w * m + a)) y->     ; [c1,c2,c3,_,c4,c5] = mceChannels (fm7 cs ms)->     ; g3 = linLin (lfSaw KR 0.1 0) (-1) 1 0 (dbAmp (-12))->     ; g5 = dbAmp (-3) }-> in audition (out 0 (mce [c1 + c3 * g3 + c5 * g5,c2 + c4 + c5 * g5]))
− Help/UGen/External/fmGrain.help.lhs
@@ -1,11 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "FMGrain"-> Sound.SC3.UGen.DB.ugenSummary "FMGrain"--> import Sound.SC3.ID--> let {t = impulse AR 20 0->     ;n = linLin (lfNoise1 'α' KR 1) (-1) 1 1 10->     ;s = envSine 9 0.1->     ;e = envGen KR 1 1 0 1 RemoveSynth s->     ;o = fmGrain t 0.2 440 220 n * e}-> in audition (out 0 o)
− Help/UGen/External/fmGrainB.help.lhs
@@ -1,15 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "FMGrainB"-> Sound.SC3.UGen.DB.ugenSummary "FMGrainB"--> import Sound.SC3.ID--> withSC3 (do {_ <- async (b_alloc 10 512 1)->             ;let f = [Normalise,Wavetable,Clear]->              in send (b_gen_sine2 10 f [(0.5,0.1)])})--> let {t = impulse AR 20 0->     ;n = linLin (lfNoise1 'a' KR 1) (-1) 1 1 10->     ;s = envSine 9 0.1->     ;e = envGen KR 1 1 0 1 RemoveSynth s->     ;o = fmGrainB t 0.2 440 220 n 10 * e}-> in audition (out 0 o)
− Help/UGen/External/lfBrownNoise.help.lhs
@@ -1,13 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "LFBrownNoise2"-> Sound.SC3.UGen.DB.ugenSummary "LFBrownNoise2"--> import Sound.SC3.ID--Modulate frequency.-> let {x = mouseX KR 0 5 Linear 0.2->     ;n = lfBrownNoise2 'α' AR 1000 1 x}-> in audition (out 0 (n * 0.25))--Use as frequency control.-> let f = lfBrownNoise2 'α' KR 8 0.2 0 * 400 + 450-> in audition (out 0 (sinOsc AR f 0 * 0.2))
− Help/UGen/External/lpcSynth.help.lhs
@@ -1,31 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "LPCSynth"-> Sound.SC3.UGen.DB.ugenSummary "LPCSynth"--> import Sound.SC3.ID--> let load_data b i d =->         if length d < 512->         then send (b_setn1 b i d)->         else do {send (b_setn1 b i (take 512 d))->                 ;load_data b (i + 512) (drop 512 d)}--> :t load_data--> let lpc_instr b n lpc =->         let {x = mouseX KR 0.05 1.5 Linear 0.2->             ;y = mouseY KR 0.25 2.0 Linear 0.2->             ;f = x / constant (lpcAnalysisDuration (lpcHeader lpc))->             ;ptr = lfSaw AR f 1 * 0.5 + 0.5->             ;[cps, rms, err] = mceChannels (lpcVals AR b ptr)->             ;nh = floorE (22000 / cps)->             ;voc = blip AR (cps * y) nh * (1 - err)->             ;s = lpcSynth b (voc + (n * err * 20)) ptr}->         in s * 1e-5 * rms--> do {lpc <- lpcRead "/home/rohan/cvs/tn/tn-56/lpc/fate.lpc"->    ;let {n = pinkNoise 'a' AR->         ;d = map realToFrac (lpcSC3 lpc)->         ;s = lpc_instr 10 n lpc}->     in withSC3 (do {_ <- async (b_alloc 10 (length d) 1)->                    ;load_data 10 0 d->                    ;play (out 0 s)})}
− Help/UGen/External/lpcVals.help.lhs
@@ -1,1 +0,0 @@-See lpcSynth
− Help/UGen/External/lti.help.lhs
@@ -1,10 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "LTI"-> Sound.SC3.UGen.DB.ugenSummary "LTI"--> import Sound.SC3.ID--> let {a = [0.02,-0.01]->     ;b = [1,0.7,0,0,0,0,-0.8,0,0,0,0,0.9,0,0,0,-0.5,0,0,0,0,0,0,0.25,0.1,0.25]->     ;z = pinkNoise 'a' AR * 0.1 {- soundIn 4 -}->     ;f = lti AR z (asLocalBuf 'a' a) (asLocalBuf 'b' b)}-> in audition (out 0 f)
− Help/UGen/External/membraneCircle.help.lhs
@@ -1,19 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "MembraneCircle"-> Sound.SC3.UGen.DB.ugenSummary "MembraneCircle"--> import Sound.SC3.ID--Excite the mesh with some pink noise, triggered by an-impulse generator.  mouseX is tension and impulse frequency,-mouseY is duration of excitation, release-time and amplitude.-> let {x = mouseX KR 0 1 Linear 0.2->     ;y = mouseY KR 1e-9 1 Exponential 0.2->     ;loss = linLin y 0 1 0.999999 0.999->     ;wobble = sinOsc KR 2 0->     ;tension = linLin x 0 1 0.01 0.1 + (wobble * 0.0001)->     ;p = envPerc 0.0001 y->     ;tr = impulse KR (linLin x 0 1 3 9) 0->     ;e = envGen KR tr (linLin y 0 1 0.05 0.25) 0 0.1 DoNothing p->     ;m = membraneCircle->     ;n = pinkNoise 'α' AR}-> in audition (out (mce2 0 1) (m (n * e) tension loss))
− Help/UGen/External/membraneHexagon.help.lhs
@@ -1,1 +0,0 @@-See membraneCircle
− Help/UGen/External/metro.help.lhs
@@ -1,16 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Metro"-> Sound.SC3.UGen.DB.ugenSummary "Metro"--> import Sound.SC3.ID--> audition (out 0 (metro AR 60 1))--> let {b = xLine KR 60 120 5 DoNothing->     ;m = metro KR b 1->     ;o = sinOsc AR 440 0 * 0.1}-> in audition (out 0 (decay m 0.2 * o))--> let {b = range 30 240 (lfNoise2 'α' KR 0.2)->     ;n = dseq 'β' dinf (mce [1,0.25,0.5,0.25])->     ;a = decay (metro KR b n) 0.2 * sinOsc AR 440 0 * 0.1}-> in audition (out 0 a)
− Help/UGen/External/mzPokey.help.lhs
@@ -1,31 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "MZPokey"-> Sound.SC3.UGen.DB.ugenSummary "MZPokey"--> import Sound.SC3-> import qualified Sound.SC3.Lang.Math as M--> let b = fromIntegral . M.parseBits :: (String -> UGen)-> let bln = line KR 0 255 5 RemoveSynth-> let mz1 i j = mzPokey i j 0 0 0 0 0 0 0-> let mz1c i j c = mzPokey i j 0 0 0 0 0 0 c--> audition (out 0 (mz1 bln (b "00001111")))-> audition (out 0 (mz1 bln (b "00101111")))-> audition (out 0 (mz1 bln (b "10101111")))-> audition (out 0 (mz1c bln (b "10101111") (b "00000001")))-> audition (out 0 (mz1c bln (b "10101111") (b "01000001")))--> let mz2c i j p q c = mzPokey i j p q 0 0 0 0 c-> let bX = mouseX KR 0 255 Linear 0.1-> let bY = mouseY KR 0 255 Linear 0.1--> audition (out 0 (mz2c bX (b "10101010") bY (b "10101010") (b "00000001")))--> let mz4pc (f1,c1) (f2,c2) (f3,c3) (f4,c4) c = mzPokey f1 c1 f2 c2 f3 c3 f4 c4 c--> let { v1 = (bX,b "11000111")->     ; v2 = (bY,b "11100111")->     ; v3 = (sinOsc KR 0.4 0 * 127.5 + 127.5,b "11000111")->     ; v4 = (sinOsc KR 0.5 0 * 127.5 + 127.5,b "01000111")->     ; m = mz4pc v1 v2 v3 v4 (b "00000000") }-> in audition (out 0 (mce2 m m))
− Help/UGen/External/playBufCF.help.lhs
@@ -1,33 +0,0 @@-wslib: external/composite--> import Sound.SC3.ID--Load sound file to buffer zero (single channel file required for examples)--> let {fn' = "/home/rohan/data/audio/pf-c5.aif"->     ;fn = "/home/rohan/opt/share/SuperCollider/sounds/a11wlk01.wav"}-> in withSC3 (async (b_allocRead 0 fn 0 0))--control-rate trigger and start-position inputs--> let {b = 0->     ;r = bufRateScale KR b->     ;tr = impulse KR 2 0->     ;wn = whiteNoise 'α' KR->     ;sp = linLin wn (-1) 1 0 (bufFrames KR b - (0.5 * 44100))->     ;o = playBufCF 1 b r tr sp NoLoop 0.1 2->     ;o' = playBuf 1 AR b r tr sp NoLoop DoNothing}-> in audition (out 0 (mce2 o o'))--demand ugens inputs--> let {b = 0->     ;r = drand 'α' dinf (mce [0.95,1,1.05])->     ;tr = dwhite 'β' dinf 0.1 0.3->     ;sp = dbrown 'γ' dinf 0 0.95 0.1 * bufFrames KR b->     ;o = playBufCF 1 b r tr sp NoLoop 2 5}-> in audition (out 0 o)--for drawings...--> import Sound.SC3.UGen.Dot {- hsc3-dot -}
− Help/UGen/External/pv_BufRd.help.lhs
@@ -1,32 +0,0 @@-> import Sound.SC3--allocate anazlysis buffer and load soundfile--> let {p = "/home/rohan/opt/share/SuperCollider/sounds/a11wlk01.wav"->     ;f = 1024 {- frame size -}->     ;h = 0.25 {- hop size -}->     ;p_dur = 4.2832879818594 {- duration (in seconds) of p -}->     ;b_size = pv_calcPVRecSize p_dur f h 48000}-> in withSC3 (do {_ <- async (b_alloc 0 b_size 1)->                ;async (b_allocRead 1 p 0 0)})--do the analysis and store to buffer.  the window type and overlaps are-important for resynthesis parameters--> let {rec_buf = 0->     ;au_buf = 1->     ;l_buf = localBuf 'α' 1024 1;->     ;rt = bufRateScale KR au_buf->     ;i = playBuf 1 AR au_buf rt 1 0 NoLoop RemoveSynth->     ;c0 = fft l_buf i 0.25 1 1 0->     ;c1 = pv_RecordBuf c0 rec_buf 0 1 0 0.25 1}-> in audition (mrg2 (out 0 (dc AR 0)) c1)--play analysis back--> let {rec_buf = 0->     ;l_buf = localBuf 'α' 1024 1->     ;x = mouseX KR 0 1 Linear 0.2->     ;c0 = pv_BufRd l_buf rec_buf x->     ;s = ifft c0 1 0}-> in audition (out 0 s)
− Help/UGen/External/pv_Invert.help.lhs
@@ -1,13 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "PV_Invert"-> Sound.SC3.UGen.DB.ugenSummary "PV_Invert"--> import Sound.SC3.ID--> let {s = sinOsc AR 440 0 * 0.4->     ;n = pinkNoise 'α' AR * 0.1->     ;i = s + n->     ;c0 = fft' 10 i->     ;c1 = pv_Invert c0->     ;run = do {_ <- async (b_alloc 10 2048 1)->               ;play (out 0 (mce2 i (ifft' c1) * 0.5))}}-> in withSC3 run
− Help/UGen/External/qitch.help.lhs
@@ -1,21 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Qitch"-> Sound.SC3.UGen.DB.ugenSummary "Qitch"--> import Sound.SC3.ID-> import System.FilePath--Load required data file (edit path as required)-> let {d = "/home/rohan/opt/share/SuperCollider/Extensions/SC3plugins"->     ;qf = d </> "PitchDetection/extraqitchfiles/QspeckernN2048SR48000.wav"}-> in withSC3 (async (b_allocRead 10 qf 0 0))--Comparison of input frequency (x) and tracked oscillator frequency (f).-Output is printed to the console by scsynth.-> let {x = mouseX KR 440 880 Exponential 0.1->     ;o = sinOsc AR x 0 * 0.1->     ;[f,e] = mceChannels (qitch KR o 10 1e-2 1 0 0 2500)->     ;r = sinOsc AR f 0 * 0.1->     ;t = impulse KR 4 0->     ;pf = poll t f (label "f") 0->     ;px = poll t x (label "x") 0}-> in audition (mrg [out 0 (mce2 o r),pf,px])
− Help/UGen/External/sms.help.lhs
@@ -1,11 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "SMS"-> Sound.SC3.UGen.DB.ugenSummary "SMS"--> import Sound.SC3--sine reconstruction left channel, noises on right-> let {z= soundIn 4->     ;y = mouseY KR 1 50 Linear 0.2->     ;x = mouseX KR 0.5 4 Linear 0.2->     ;o = sms z 50 y 8 0.3 x 0 0 0 1 (-1)}-> in audition (out 0 o)
− Help/UGen/External/squiz.help.lhs
@@ -1,27 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Squiz"-> Sound.SC3.UGen.DB.ugenSummary "Squiz"--> import Sound.SC3--Squiz of sin oscillator--> let {o = sinOsc AR 440 0->     ;x = mouseX KR 1 10 Exponential 0.2->     ;y = mouseY KR 1 10 Linear 0.2->     ;s = squiz o x y 0.1 * 0.1}-> in audition (out 0 s)--Load sound file to buffer zero--> let {fn' = "/home/rohan/data/audio/pf-c5.aif"->     ;fn = "/home/rohan/opt/share/SuperCollider/sounds/a11wlk01.wav"}-> in withSC3 (async (b_allocRead 0 fn 0 0))--Squiz of audio file.--> let {r = bufRateScale KR 0->     ;p = playBuf 1 AR 0 (r * 0.5) 1 0 Loop DoNothing->     ;x = mouseX KR 1 100 Exponential 0.2->     ;y = mouseY KR 1 10 Linear 0.2->     ;o = squiz p x y 0.1 * 0.5}-> in audition (out 0 o)
− Help/UGen/External/stkBowed.help.lhs
@@ -1,8 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "StkBowed"-> Sound.SC3.UGen.DB.ugenSummary "StkBowed"--> import Sound.SC3--no longer working...-> let g = toggleFF (impulse KR 1 0)-> in audition (out 0 (stkBowed AR 220 64 64 64 64 64 g 1 1))
− Help/UGen/External/stkFlute.help.lhs
@@ -1,8 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "StkFlute"-> Sound.SC3.UGen.DB.ugenSummary "StkFlute"--> import Sound.SC3--> let { bp = line KR 76 32 3 RemoveSynth->     ; ng = line KR 16 64 3 DoNothing }-> in audition (out 0 (stkFlute AR 400 64 ng 16 16 bp 1))
− Help/UGen/External/stkMandolin.help.lhs
@@ -1,24 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "StkMandolin"-> Sound.SC3.UGen.DB.ugenSummary "StkMandolin"--> import Control.Monad-> import Sound.SC3.ID-> import qualified Sound.SC3.Monad as M--requires "../../rawwaves/mand1.raw"-> let {x = mouseX KR 0.25 4 Linear 0.2->     ;tr = impulse KR x 0 - 0.5 }-> in do {mn <- M.tRand 54 66 tr->       ;[bs, pp, dm, dt, at] <- replicateM 5 (M.tRand 0 127 tr)->       ;audition (out 0 (stkMandolin AR (midiCPS mn) bs pp dm dt at tr))}--> let {x = mouseX KR 3 16 Linear 0.2->     ;t = impulse KR x 0 - 0.5->     ;tr = pulseDivider t 6 0 }-> in do {mn <- M.tIRand 54 66 t->       ;bs <- M.tRand 72 94 tr->       ;pp <- M.tRand 32 42 tr->       ;dm <- M.tRand 64 72 tr->       ;dt <- M.tRand 0 4 tr->       ;at <- M.tRand 2 8 tr->       ;audition (out 0 (stkMandolin AR (midiCPS mn) bs pp dm dt at t))}
− Help/UGen/External/stkModalBar.help.lhs
@@ -1,29 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "StkModalBar"-> Sound.SC3.UGen.DB.ugenSummary "StkModalBar"--> import Control.Monad-> import Sound.SC3.ID-> import qualified Sound.SC3.Monadic as M--requires "../../rawwaves/marmstk1.raw"-> let {x = mouseX KR 0.25 4 Linear 0.2->     ;tr = impulse KR x 0 - 0.5->     ;tR = M.tRand 0 127 tr}-> in do {i <- M.tRand 0 9 tr->       ;mn <- M.tIRand 25 96 tr->       ;[sh,sp,vg,vf,mx,v] <- replicateM 6 tR->       ;let s = stkModalBar AR (midiCPS mn) i sh sp vg vf mx v tr->        in audition (out 0 s)}--> let {x = mouseX KR 1 6 Linear 0.2->     ;t = impulse KR x 0 - 0.5->     ;tr = pulseDivider t 6 0}-> in do {mn <- M.tIRand 52 64 t->       ;sh <- M.tRand 4 8 tr->       ;sp <- M.tRand 54 68 tr->       ;vg <- M.tRand 66 98 tr->       ;vf <- M.tRand 4 12 tr->       ;mx <- M.tRand 0 1 tr->       ;v <- M.tRand 16 48 tr->       ;let s = stkModalBar AR (midiCPS mn) 1 sh sp vg vf mx v t->        in audition (out 0 s)}
− Help/UGen/External/stkShakers.help.lhs
@@ -1,15 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "StkShakers"-> Sound.SC3.UGen.DB.ugenSummary "StkShakers"--> import Control.Monad-> import Sound.SC3.ID-> import qualified Sound.SC3.Monadic as M--> let {x = mouseX KR 0.25 4 Linear 0.2->     ;tr = impulse KR x 0 - 0.5}-> in do {i <- M.tRand 0 23 tr->       ;[e,sd,no,rf] <- replicateM 4 (M.tRand 0 127 tr)->       ;audition (out 0 (stkShakers AR i e sd no rf tr))}--> let tr = impulse KR 1 0 - 0.5-> in audition (out 0 (stkShakers AR 4 64 64 64 64 tr))
− Help/UGen/External/streson.help.lhs
@@ -1,8 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Streson"-> Sound.SC3.UGen.DB.ugenSummary "Streson"--> import Sound.SC3--> let {dt = recip (linExp (lfCub KR 0.1 (0.5 * pi)) (-1) 1 280 377)->     ;s = streson (lfSaw AR (mce2 220 180) 0 * 0.2) dt 0.9 * 0.3}-> in audition (out 0 s)
− Help/UGen/External/switchDelay.help.lhs
@@ -1,13 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "SwitchDelay"-> Sound.SC3.UGen.DB.ugenSummary "SwitchDelay"--> import Sound.SC3--simple feedback delay-> audition (out 0 (switchDelay (soundIn 4) 1 1 1 0.99 20))--change the buffer read pointer periodically.-> let {ix = stepper (impulse KR 0.5 0) 0 0 3 1 0->     ;dt = select ix (mce [0.02,0.1,0.725,0.25])->     ;sd = switchDelay (soundIn 4) 1 1 dt 0.99 20}-> in audition (out 0 sd)
− Help/UGen/External/tBetaRand.help.lhs
@@ -1,17 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "TBetaRand"-> Sound.SC3.UGen.DB.ugenSummary "TBetaRand"--> import Sound.SC3.ID--> let {t = dust 'α' KR 10->     ;f = tBetaRand 'β' 300 3000 0.1 0.1 t->     ;o = sinOsc AR f 0 * 0.1}-> in audition (out 0 o)--mouse control of parameters-> let {t = dust 'α' KR 10->     ;p1 = mouseX KR 1 5 Linear 0.2->     ;p2 = mouseY KR 1 5 Linear 0.2->     ;f = tBetaRand 'β' 300 3000 p1 p2 t->     ;o = sinOsc AR f 0 * 0.1}-> in audition (out 0 o)
− Help/UGen/External/tBrownRand.help.lhs
@@ -1,18 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "TBrownRand"-> Sound.SC3.UGen.DB.ugenSummary "TBrownRand"--> import Sound.SC3.ID--> let {t = dust 'α' KR 10->     ;dist = mouseX KR 0 5 Linear 0.2->     ;f = tBrownRand 'β' 300 3000 1 dist t->     ;o = sinOsc AR f 0 * 0.1}-> in audition (out 0 o)--> let {t = dust 'α' KR 10->     ;n = tBrownRand 'β' 0 1 0.2 0 t->     ;f = linExp n 0 1 300 3000->     ;o = sinOsc AR f 0->     ;l = tBrownRand 'γ' (-1) 1 1 4 t->     ;p = pan2 o l 0.1}-> in audition (out 0 p)
− Help/UGen/External/tGaussRand.help.lhs
@@ -1,19 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "TGaussRand"-> Sound.SC3.UGen.DB.ugenSummary "TGaussRand"--> import Sound.SC3.ID--> let {t = dust 'α' KR 10->     ;f = tGaussRand 'β' 300 3000 t->     ;o = sinOsc AR f 0->     ;l = tGaussRand 'γ' (-1) 1 t->     ;p = pan2 o l 0.1}-> in audition (out 0 p)--compare to tRand-> let {t = dust 'α' KR 10->     ;f = tRand 'β' 300 3000 t->     ;o = sinOsc AR f 0->     ;l = tRand 'γ' (-1) 1 t->     ;p = pan2 o l 0.1}-> in audition (out 0 p)
− Help/UGen/External/tartini.help.lhs
@@ -1,19 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Tartini"-> Sound.SC3.UGen.DB.ugenSummary "Tartini"--> import Sound.SC3.ID--Comparison of input frequency (x) and tracked oscillator frequency (f).-> let {x = mouseX KR 440 880 Exponential 0.1->     ;o = lfSaw AR x 0 * 0.05 {- sinOsc AR x 0 * 0.1 -}->     ;[f,e] = mceChannels (tartini KR o 0.2 2048 0 1024 0.5)->     ;r = sinOsc AR f 0 * 0.1->     ;t = impulse KR 4 0->     ;pf = poll t f (label "f") 0->     ;px = poll t x (label "x") 0}-> in audition (mrg [out 0 (mce2 o r),pf,px])--Fast test of live pitch tracking, not careful with amplitude of input-> let {z = soundIn 4->     ;[f,e] = mceChannels (tartini KR z 0.2 2048 0 1024 0.5)}-> in audition (out 0 (saw AR f * 0.05 * e))
− Help/UGen/External/tpv.help.lhs
@@ -1,25 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "TPV"-> Sound.SC3.UGen.DB.ugenSummary "TPV"--> import Sound.SC3--> let fft_sz = 2048::Int-> let hop_sz = fft_sz `div` 2-> let fn = "/home/rohan/data/audio/pf-c5.snd"-> let fn = "/home/rohan/data/audio/material/tyndall/var/talking-fragments/0001.WAV"-> let tpv' b i = tpv (fft b i 0.5 1 1 0) (constant fft_sz) (constant hop_sz)--> withSC3 (do {_ <- async (b_alloc 0 fft_sz 1)->             ;async (b_allocRead 1 fn 0 0)})--> let {i = playBuf 1 AR 1 (bufRateScale KR 1) 1 0 Loop DoNothing->     ;x = mouseX KR 1 70 Linear 0.1->     ;y = mouseY KR 0.25 3 Linear 0.1->     ;o = tpv' 0 i 70 x y 4 0.2}-> in audition (out 0 (mce2 (i * 0.1) o))--> let {i = playBuf 1 AR 1 (bufRateScale KR 1) 1 0 Loop DoNothing->     ;x = mouseX KR 0.1 100 Linear 0.1->     ;y = mouseY KR (-20) 40 Linear 0.1->     ;o = tpv' 0 i 50 50 1 x (dbAmp y)}-> in audition (out 0 (pan2 o 0 1))
− Help/UGen/External/vosim.help.lhs
@@ -1,22 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "VOSIM"-> Sound.SC3.UGen.DB.ugenSummary "VOSIM"--> import Sound.SC3.ID--> let {p = tRand 'α' 0 1 (impulse AR 6 0)->     ;t = impulse AR (9 * ( 1 + ( p >* 0.95))) 0->     ;x = mouseX KR 0.25 2 Linear 0.2->     ;y = mouseY KR 0.25 0.75 Linear 0.2->     ;z = 9->     ;rng i = linLin i (-1) 1->     ;mk_n e = rng (lfNoise2 e KR z) 0.25 2->     ;tR e ll rl = tRand e (mce ll) (mce rl)->     ;f = tR 'β' [40,120,220] [440,990,880] t->     ;n = tR 'γ' [4] [8,16,32] t->     ;d = tR 'δ' [0.2,0.4,0.6] [0.6,0.8,1] t->     ;a = tR 'ε' [0] [0.05,0.15,0.25] t->     ;l = tR 'ζ' [-1] [1] t->     ;xn = mk_n 'η'->     ;yn = mk_n 'θ'->     ;v = vosim t (f * x * xn) n (d * y * yn) * a}-> in audition (out 0 (pan2 (mix v) l 1))
− Help/UGen/External/waveTerrain.help.lhs
@@ -1,74 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "WaveTerrain"-> Sound.SC3.UGen.DB.ugenSummary "WaveTerrain"--> import Sound.SC3.ID {- hsc3 -}-> import Sound.SC3.Plot {- hsc3-plot -}--Terrain function--> let z (x,y) = let {a = x ** 2->                   ;b = abs (sin (10 * y)) ** (1/3)}-> in 2 * (a + b) - 1--Create terrain given function.--> let t z = let {w = 100 {- width -}->               ;h = 50 {- height -}->               ;tk n = take (round n)->               ;xs = tk w [0,1/w ..]->               ;ys = tk h [0,1/h ..]->               ;ix = map (\y -> map (\x -> (x,y)) xs) ys->               ;add_z = map (\(x,y) -> (x,y,z (x,y)))}->           in concatMap add_z ix--Confirm terrain--> plot_p3_pt [t z]--Create table.--> let t' = map (\(_,_,z) -> z) (t z)--Confirm table--> plotTable [t']--Send table to scsynth--> withSC3 (async (b_alloc_setn1 0 0 t'))--Hear terrain--> let {x' = mouseX KR 1 200 Exponential 0.2->     ;y' = mouseY KR 1 300 Exponential 0.2->     ;x = abs (sinOsc AR x' 0) + lfNoise2 'α' AR 2->     ;y = abs (sinOsc AR y' (pi / 2))->     ;b = 0->     ;o = waveTerrain AR b x y 100 50}-> in audition (out 0 o)--Alternate terrain function.--> let z (x,y) = let {a = (cos(5 * x + 1.7)) ** 3->                   ;b = abs (sin (23 * y)) ** (1/3)}->               in (a - b)--Free buffer--> withSC3 (async (b_free 0))--Gerate mesh given terrain given function.--> let t z = let {w = 100 {- width -}->               ;h = 50 {- height -}->               ;tk n = take (round n)->               ;xs = tk w [0,1/w ..]->               ;ys = tk h [0,1/h ..]->               ;ix0 = map (\y -> map (\x -> (x,y)) xs) ys->               ;ix1 = map (\x -> map (\y -> (x,y)) ys) xs->               ;add_z = map (\(x,y) -> (x,y,z (x,y)))}->           in (map add_z ix0,map add_z ix1)--Confirm terrain mesh--> plot_p3_ln ((\(p,q) -> p ++ q) (t z))
− Help/UGen/External/zitaRev1.help.lhs
@@ -1,34 +0,0 @@-faust2supercollider zita_rev1.dsp-http://kokkinizita.linuxaudio.org/linuxaudio/zita-rev1-doc/quickguide.html--delay, lin,   0.02,    0.1,     0.04-xover, log,  50.0,  1000.0,   200.0-rtlow, log,   1.0,     8.0,     3.0-rtmid, log,   1.0,     8.0,     2.0-fdamp, log,   1.5e3,  24.0e3,   6.0e3-eq1fr, log,  40.0,     2.5e3, 160.0-eq1gn, lin, -15.0,    15.0,     0.0-eq2fr, log, 160.0,    10.0e3,   2.5e3-eq2gn, lin, -15.0,    15.0,     0.0-opmix, lin,   0.0,     1.0,     0.5-level, lin,  -9.0,     9.0,   -20.0--> import Sound.SC3--default settings-> let {i = soundIn 4->     ;o = zitaRev1 i i 0.04 200 3 2 6000 160 0 2500 0 0.5 (-6)}-> in audition (out 0 o)--longer-> let {i = soundIn 4->     ;o = zitaRev1 i i 0.08 200 6 4 6000 190 (-6) 3500 6 0.5 0}-> in audition (out 0 o)--longer still-> let {i = soundIn 4->     ;o = zitaRev1 i i 0.1 200 6 8 6000 190 (-6) 3500 6 0.5 0}-> in audition (out 0 o)--hsc3-db-> Sound.SC3.UGen.DB.u_summary zitaRev1_dsc
− Help/UGen/FFT/convolution.help.lhs
@@ -1,8 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Convolution"-> Sound.SC3.UGen.DB.ugenSummary "Convolution"--> import Sound.SC3.ID--> let {k = whiteNoise 'a' AR->     ;i = in' 2 AR numOutputBuses}-> in audition (out 0 (convolution i k 2048 * 0.1))
− Help/UGen/FFT/fft.help.lhs
@@ -1,21 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "FFT"-> Sound.SC3.UGen.DB.ugenSummary "FFT"-> :t fft'--> import Sound.SC3.ID--Non-local buffer--> withSC3 (async (b_alloc 10 2048 1))--Variants with default values--> let n = whiteNoise 'α' AR-> in audition (out 0 (ifft' (fft' 10 (n * 0.05))))--Local buffer allocating fft variant--> let {s0 = sinOsc KR 0.08 0 * 6 + 6.2->     ;s1 = sinOsc KR (squared s0) 0 * 100 + 800->     ;s2 = sinOsc AR s1 0}-> in audition (out 0 (ifft (ffta 'α' 2048 s2 0.5 0 1 0) 0 0 * 0.25))
− Help/UGen/FFT/fftTrigger.help.lhs
@@ -1,2 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "FFTTrigger"-> Sound.SC3.UGen.DB.ugenSummary "FFTTrigger"
− Help/UGen/FFT/ifft.help.lhs
@@ -1,5 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "IFFT"-> Sound.SC3.UGen.DB.ugenSummary "IFFT"-> :t ifft'--# ifft' is a variant with the default window type and size
− Help/UGen/FFT/packFFT.help.lhs
@@ -1,23 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "PackFFT"-> Sound.SC3.UGen.DB.ugenSummary "PackFFT"--> import Sound.SC3.ID-> import Sound.SC3.UGen.Protect--> withSC3 (async (b_alloc 10 512 1))--> let {n = 100->     ;square a = a * a->     ;r1 = let f = expRand 'α' 0.1 1->           in linLin (fSinOsc KR f 0) (-1) 1 0 1->     ;m1 = uclone' 'β' n r1->     ;m2 = zipWith (*) m1 (map square [1.0, 0.99 ..])->     ;r2 = let r = iRand 'γ' (-3) 5->           in lfPulse KR (2 ** r) 0 0.3->     ;i = uclone' 'δ' n r2->     ;m3 = zipWith (*) m2 i->     ;p = replicate n 0.0->     ;c1 = fft' 10 (fSinOsc AR 440 0)->     ;c2 = packFFT c1 512 0 (constant n - 1) 1 (packFFTSpec m3 p)->     ;s = ifft' c2}-> in audition (out 0 (mce [s,s]))
− Help/UGen/FFT/partConv.help.lhs
@@ -1,23 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "PartConv"-> Sound.SC3.UGen.DB.ugenSummary "PartConv"--> import Sound.SC3.ID--> let { fft_size = 2048->     ; ir_file = "/home/rohan/data/audio/reverbs/chapel.wav"->     ; ir_length = 62494 {- frame count of ir_file -}->     ; accum_size = pc_calcAccumSize fft_size ir_length->     ; ir_td_b = 10 {- time domain -}->     ; ir_fd_b = 11 {- frequency domain -}->     ; target_b = 12 {- source signal -}->     ; target_file = "/home/rohan/data/audio/pf-c5.snd"->     ; c = constant->     ; g = let { i = playBuf 1 AR (c target_b) 1 0 0 Loop DoNothing->               ; pc = partConv i (c fft_size) (c ir_fd_b) }->           in out 0 (pc * 0.1) }-> in withSC3 (do->     {_ <- async (b_allocRead ir_td_b ir_file 0 ir_length)->     ;_ <- async (b_alloc ir_fd_b accum_size 1)->     ;send (pc_preparePartConv ir_fd_b ir_td_b fft_size)->     ;_ <- async (b_allocRead target_b target_file 0 0)->     ;play g })
− Help/UGen/FFT/pv_BinDelay.help.lhs
@@ -1,57 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "PV_BinDelay"-> Sound.SC3.UGen.DB.ugenSummary "PV_BinDelay"--> import Sound.SC3--function to allocate buffers (fft,delay,feedback)--> let mk_b sz = withSC3 (do {_ <- async (b_alloc 10 (sz * 2) 1)->                           ;_ <- async (b_alloc 11 sz 1)->                           ;async (b_alloc 12 sz 1)})--allocate buffers (number of bins)--> mk_b 128--function to generate bindelay filter--> let mk_u z = let {maxdel = 0.5->                  ;c1 = fft 10 z 0.25 0 1 0->                  ;c2 = pv_BinDelay c1 maxdel 11 12 0.25}->              in z + ifft c2 0 0--start filter--> audition (out 0 (mk_u (soundIn 4)))--set delay times (unary)--> withSC3 (send (b_fill 11 [(0,128,0.25)]))--set feedback gain--> withSC3 (send (b_fill 12 [(0,128,0.75)]))--function to generate sin table of n places in range (l,r)--> let gen_sin l r n ph =->     let f x = range l r (sin ((x / n) * 2 * pi + ph))->     in map f [0..n]--set delay times (sin)--> withSC3 (send (b_setn1 11 0 (gen_sin 0 0.35 128 0)))--set feedback gain (sin)--> withSC3 (send (b_setn1 12 0 (gen_sin 0.75 0.95 128 pi)))--modulate delay times (lfo)--> let o = range 0.15 0.35 (blip KR (1/23) 3)-> in audition (recordBuf KR 11 0 1 0 1 Loop 1 DoNothing o)--modulate feedback gains (lfo)--> let o = range 0.75 0.95 (blip KR (1/25) 5)-> in audition (recordBuf KR 12 0 1 0 1 Loop 1 DoNothing o)
− Help/UGen/FFT/pv_BinScramble.help.lhs
@@ -1,25 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "PV_BinScramble"-> Sound.SC3.UGen.DB.ugenSummary "PV_BinScramble"--> import Sound.SC3.ID--> let fileName = "/home/rohan/data/audio/pf-c5.snd"-> in withSC3 (do {_ <- async (b_alloc 10 2048 1)->                ;async (b_allocRead 12 fileName 0 0)})--> let {a = playBuf 1 AR 12 (bufRateScale KR 12) 1 0 Loop DoNothing->     ;f = fft' 10 a->     ;x = mouseX KR 0.0 1.0 Linear 0.1->     ;y = mouseY KR 0.0 1.0 Linear 0.1->     ;g = pv_BinScramble 'α' f x y (impulse KR 4 0)}-> in audition (out 0 (pan2 (ifft' g) 0 0.5))--careful - feedback loop!-> let {a = soundIn (mce2 4 5) * 4->     ;f = fft' 10 a->     ;x = mouseX KR 0.15 1 Linear 0.1->     ;y = mouseY KR 0.15 1 Linear 0.1->     ;i = impulse KR (lfNoise0 'α' KR 2 * 8 + 10) 0->     ;g = pv_BinScramble 'β' f x y i->     ;h = ifft' g}-> in audition (out 0 (pan2 h 0 0.5))
− Help/UGen/FFT/pv_BinShift.help.lhs
@@ -1,25 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "PV_BinShift"-> Sound.SC3.UGen.DB.ugenSummary "PV_BinShift"--> import Sound.SC3.ID--allocate buffer-> withSC3 (async (b_alloc 10 2048 1))--source signal (oscillators)-> let z = let {s0 = sinOsc KR 0.08 0 * 6 + 6.2->             ;s1 = sinOsc KR (squared s0) 0 * 100 + 800}->         in sinOsc AR s1 0 * 0.2--source signal (the world)-> let z = soundIn 4--default values-> audition (out 0 (ifft' (pv_BinShift (fft' 10 z) 1 0 0)))--mouse control-> let {x = mouseX KR (-10) 100 Linear 0.1->     ;y = mouseY KR 1 4 Linear 0.1->     ;b = mouseButton KR 0 1 0.2->     ;pv = pv_BinShift (fft' 10 z) y x b}-> in audition (out 0 (ifft' pv))
− Help/UGen/FFT/pv_BinWipe.help.lhs
@@ -1,17 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "PV_BinWipe"-> Sound.SC3.UGen.DB.ugenSummary "PV_BinWipe"--> import Sound.SC3.ID--> let fileName = "/home/rohan/data/audio/pf-c5.snd"-> in withSC3 (do {_ <- async (b_alloc 10 2048 1)->                ;_ <- async (b_alloc 11 2048 1)->                ;async (b_allocRead 12 fileName 0 0)})--> let {n = whiteNoise 'α' AR->     ;b = playBuf 1 AR 12 (bufRateScale KR 12) 0 0 Loop DoNothing->     ;f = fft' 10 (n * 0.2)->     ;g = fft' 11 b->     ;x = mouseX KR 0.0 1.0 Linear 0.1->     ;h = pv_BinWipe f g x}-> in audition (out 0 (pan2 (ifft' h) 0 0.5))
− Help/UGen/FFT/pv_BrickWall.help.lhs
@@ -1,10 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "PV_BrickWall"-> Sound.SC3.UGen.DB.ugenSummary "PV_BrickWall"--> import Sound.SC3.ID--> withSC3 (async (b_alloc 10 2048 1))--> let {n = whiteNoise 'α' AR->     ;x = mouseX KR (-1) 1 Linear 0.1}-> in audition (out 0 (ifft' (pv_BrickWall (fft' 10 (n * 0.2)) x)))
− Help/UGen/FFT/pv_ConformalMap.help.lhs
@@ -1,26 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "PV_ConformalMap"-> Sound.SC3.UGen.DB.ugenSummary "PV_ConformalMap"--> import Sound.SC3.ID--> withSC3 (async (b_alloc 10 1024 1))--> let { i = soundIn 4->     ; x = mouseX KR (-1) 1 Linear 0.1->     ; y = mouseY KR (-1) 1 Linear 0.1 }-> in audition (out 0 (pan2 (ifft' (pv_ConformalMap (fft' 10 i) x y)) 0 1))--With filtering.-> withSC3 (async (b_alloc 0 2048 1))--> let z = let {o = mce [1, 1.1, 1.5, 1.78, 2.45, 6.7, 8] * 220->             ;f = sinOsc KR (mce [0.16, 0.33, 0.41]) 0 * 10 + o}->         in mix (lfSaw AR f 0) * 0.3--> let z = soundIn 4--> let {x = mouseX KR 0.01  2.0 Linear 0.1->     ;y = mouseY KR 0.01 10.0 Linear 0.1->     ;c = fft' 0 z->     ;m = ifft' (pv_ConformalMap c x y)}-> in audition (out 0 (pan2 (combN m 0.1 0.1 10 * 0.5 + m) 0 1))
− Help/UGen/FFT/pv_Diffuser.help.lhs
@@ -1,17 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "PV_Diffuser"-> Sound.SC3.UGen.DB.ugenSummary "PV_Diffuser"--> import Sound.SC3.ID--> let fileName = "/home/rohan/data/audio/pf-c5.snd"-> in withSC3 (do {_ <- async (b_alloc 10 2048 1)->                ;async (b_allocRead 12 fileName 0 0)})--> let z = playBuf 1 AR 12 (bufRateScale KR 12) 0 0 Loop DoNothing--> let z = soundIn 4--> let {f = fft' 10 z->     ;x = mouseX KR 0 1 Linear 0.1->     ;h = pv_Diffuser f (x >* 0.5) }-> in audition (out 0 (ifft' h * 0.5))
− Help/UGen/FFT/pv_HainsworthFoote.help.lhs
@@ -1,12 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "PV_HainsworthFoote"-> Sound.SC3.UGen.DB.ugenSummary "PV_HainsworthFoote"--> import Sound.SC3.ID--> let {i = soundIn 4->     ;b = localBuf 'α' 2048 1->     ;f = fft' b i->     ;x = mouseX KR 0.5 1.25 Linear 0.2->     ;h = pv_HainsworthFoote f 1 0 x 0.04->     ;o = sinOsc AR (mrg2 440 445) 0 * decay (h * 0.1) 0.1}-> in audition (out 0 (o + i))
− Help/UGen/FFT/pv_LocalMax.help.lhs
@@ -1,14 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "PV_LocalMax"-> Sound.SC3.UGen.DB.ugenSummary "PV_LocalMax"--> import Sound.SC3.ID--> let fileName = "/home/rohan/data/audio/pf-c5.snd"-> in withSC3 (do {_ <- async (b_alloc 10 2048 1)->                ;async (b_allocRead 12 fileName 0 0)})--> let { a = playBuf 1 AR 12 (bufRateScale KR 12) 0 0 Loop DoNothing->     ; f = fft' 10 a->     ; x = mouseX KR 0 100 Linear 0.1->     ; h = pv_LocalMax f x }-> in audition (out 0 (ifft' h * 0.5))
− Help/UGen/FFT/pv_MagAbove.help.lhs
@@ -1,22 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "PV_MagAbove"-> Sound.SC3.UGen.DB.ugenSummary "PV_MagAbove"--> import Sound.SC3.ID--> let fileName = "/home/rohan/data/audio/pf-c5.snd"-> in withSC3 (do {_ <- async (b_alloc 10 2048 1)->                ;async (b_allocRead 12 fileName 0 0) })--> let {a = playBuf 1 AR 12 (bufRateScale KR 12) 0 0 Loop DoNothing->     ;f = fft' 10 a->     ;x = mouseX KR 0 100 Linear 0.1->     ;h = pv_MagAbove f x}-> in audition (out 0 (ifft' h * 0.5))--Synthesised input.-> let {a = sinOsc KR (squared (sinOsc KR 0.08 0 * 6 + 6.2)) 0 * 100 + 800->     ;b = sinOsc AR a 0->     ;f = fft' 10 b->     ;x = mouseX KR 0 1024 Linear 0.1->     ;h = pv_MagAbove f x}-> in audition (out 0 (ifft' h * 0.5))
− Help/UGen/FFT/pv_MagBelow.help.lhs
@@ -1,22 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "PV_MagBelow"-> Sound.SC3.UGen.DB.ugenSummary "PV_MagBelow"--> import Sound.SC3.ID--> let fileName = "/home/rohan/data/audio/pf-c5.snd"-> in withSC3 (do {_ <- async (b_alloc 10 2048 1)->                ;async (b_allocRead 12 fileName 0 0)})--> let { a = playBuf 1 AR 12 (bufRateScale KR 12) 0 0 Loop DoNothing->     ; f = fft' 10 a->     ; x = mouseX KR 0 100 Linear 0.1->     ; h = pv_MagBelow f x }-> in audition (out 0 (ifft' h * 0.5))--Synthesised input.-> let { a = sinOsc KR (squared (sinOsc KR 0.08 0 * 6 + 6.2)) 0 * 100 + 800->     ; b = sinOsc AR a 0->     ; f = fft' 10 b->     ; x = mouseX KR 0 1024 Linear 0.1->     ; h = pv_MagBelow f x }-> in audition (out 0 (ifft' h * 0.5))
− Help/UGen/FFT/pv_MagClip.help.lhs
@@ -1,25 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "PV_MagClip"-> Sound.SC3.UGen.DB.ugenSummary "PV_MagClip"--> import Sound.SC3.ID--> let fileName = "/home/rohan/data/audio/pf-c5.snd"-> in withSC3 (do {_ <- async (b_alloc 10 2048 1)->                ;async (b_allocRead 12 fileName 0 0)})--File input-> let z = playBuf 1 AR 12 (bufRateScale KR 12) 0 0 Loop DoNothing--Synthesised input.-> let z = let {f0 = squared (sinOsc KR 0.08 0 * 6 + 6.2)->             ;f1 = sinOsc KR f0 0 * 100 + 800}->         in sinOsc AR f1 0--Outside world-> let z = soundIn 4--> let {f = fft' 10 z->     ;c = 128->     ;x = mouseX KR 0 c Linear 0.1->     ;h = pv_MagClip f x}-> in audition (out 0 (ifft' h * 0.5))
− Help/UGen/FFT/pv_MagFreeze.help.lhs
@@ -1,31 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "PV_MagFreeze"-> Sound.SC3.UGen.DB.ugenSummary "PV_MagFreeze"--> import Sound.SC3.ID {- hsc3 -}--Load audio file.--> let fileName = "/home/rohan/data/audio/pf-c5.snd"-> in withSC3 (do {_ <- async (b_alloc 10 2048 1)->                ;async (b_allocRead 12 fileName 0 0)})--File as signal...--> let z = playBuf 1 AR 12 (bufRateScale KR 12) 0 0 Loop DoNothing--Synthesised signal...--> let z = let {o1 = sinOsc KR 0.08 0->             ;o2 = sinOsc KR (squared (o1 * 6 + 6.2)) 0 * 100 + 800}->         in sinOsc AR o2 0--Outside world signal...--> let z = soundIn 4--Process (freeze) 'z'...--> let {f = fft' 10 z->     ;x = mouseX KR 0 1 Linear 0.1->     ;h = pv_MagFreeze f (x >* 0.5)}-> in audition (out 0 (ifft' h * 0.5))
− Help/UGen/FFT/pv_RandComb.help.lhs
@@ -1,19 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "PV_RandComb"-> Sound.SC3.UGen.DB.ugenSummary "PV_RandComb"--> import Sound.SC3.ID--allocate buffer-> withSC3 (async (b_alloc 10 2048 1))--noise signal-> let z = whiteNoise 'a' AR * 0.5--outside world-> let z = soundIn 4--processor-> let {t = impulse KR 0.1 0->     ;x = mouseX KR 0.6 0.95 Linear 0.1->     ;c = pv_RandComb 'a' (fft' 10 z) x t}-> in audition (out 0 (pan2 (ifft' c) 0 1))
− Help/UGen/FFT/pv_RandWipe.help.lhs
@@ -1,23 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "PV_RandWipe"-> Sound.SC3.UGen.DB.ugenSummary "PV_RandWipe"--> import Sound.SC3.ID-> import qualified System.Random as R--> withSC3 (do {_ <- async (b_alloc 10 2048 1)->             ;async (b_alloc 11 2048 1)})--> let { n0 = R.randomRs (400.0, 1000.0) (R.mkStdGen 0)->     ; n1 = R.randomRs (80.0, 400.0) (R.mkStdGen 1)->     ; n2 = R.randomRs (0.0, 8.0) (R.mkStdGen 2)->     ; o0 = map (\n -> lfSaw AR n 0 * 0.1) (take 6 n0)->     ; o1 = map (\n -> lfPulse AR n 0.0 0.2) (take 6 n1)->     ; o2 = map (\n -> sinOsc KR n 0 * 0.2) (take 6 n2)->     ; a = mix (mce o0)->     ; b = mix (mce (zipWith (\p s -> p * (max s 0.0)) o1 o2))->     ; f = fft' 10 a->     ; g = fft' 11 b->     ; x = mouseX KR 0 1 Linear 0.1->     ; y = mouseY KR 0 1 Linear 0.1->     ; h = pv_RandWipe 'a' f g x (y >* 0.5) }-> in audition (out 0 (pan2 (ifft' h) 0 0.5))
− Help/UGen/FFT/pv_RectComb.help.lhs
@@ -1,22 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "PV_RectComb"-> Sound.SC3.UGen.DB.ugenSummary "PV_RectComb"--> import Sound.SC3.ID--> withSC3 (async (b_alloc 10 2048 1))--noise source-> let z = whiteNoise 'a' AR * 0.3--outside world-> let z = soundIn 4--> let {x = mouseX KR 0 0.5 Linear 0.1->     ;y = mouseY KR 0 0.5 Linear 0.1->     ;c = pv_RectComb (fft' 10 z) 8 x y}-> in audition (out 0 (pan2 (ifft' c) 0 1))--> let {p = lfTri KR 0.097 0 *   0.4  + 0.5->     ;w = lfTri KR 0.240 0 * (-0.5) + 0.5->     ;c = pv_RectComb (fft' 10 z) 8 p w}-> in audition (out 0 (pan2 (ifft' c) 0 1))
− Help/UGen/FFT/pvcollect.help.lhs
@@ -1,52 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "PV_ChainUGen.pvcollect"-> :t pvcollect--> import Data.List {- base -}-> import Sound.SC3 {- hsc3 -}--> let fileName = "/home/rohan/data/audio/pf-c5.snd"-> in withSC3 (do {_ <- async (b_alloc 10 1024 1)->                ;async (b_allocRead 11 fileName 0 0)})--> let spectral_delay m p _ =->     let {l = lfPar KR 0.5 0->         ;v = linLin l (-1) 1 0.1 1}->     in (m + delayN m 1 v,p)--> let bpf_sweep nf m p i =->     let {l = lfPar KR 0.1 0->         ;e = abs (i - (linLin l (-1) 1 2 (nf / 20)))}->     in ((e <* 10) * m,p)--> let pv_g nf cf =->   let {no_op m p _ = (m,p)->       ;combf m p i = ((modE i 7.0 ==* 0) * m,p)->       ;sf = playBuf 1 AR 11 (bufRateScale KR 11) 1 0 Loop DoNothing->       ;c1 = fft' 10 sf->       ;c2 = pvcollect c1 nf cf 0 250 0}->   in out 0 (0.1 * ifft' c2)--> let pv_au nf cf =->   let {no_op m p _ = (m,p)->       ;combf m p i = ((modE i 7.0 ==* 0) * m,p)->       ;c1 = fft' 10 (soundIn 0)->       ;c2 = pvcollect c1 nf cf 0 250 0}->   in out 0 (0.1 * ifft' c2)--> let r = unlines ["number of constants       : 257"->                 ,"number of controls        : 0"->                 ,"control rates             : []"->                 ,"number of unit generators : 1013"->                 ,"unit generator rates      : [(KR,5),(AR,4),(DR,1004)]"]-> in r `isPrefixOf` synthstat (pv_g 1024 spectral_delay)--> synthstat (pv_g 1024 (bpf_sweep 1024))-> audition (pv_g 1024 spectral_delay)-> audition (pv_g 1024 (bpf_sweep 1024))--> audition (pv_au 1024 spectral_delay)-> audition (pv_au 1024 (bpf_sweep 1024))--> import Sound.SC3.UGen.Dot {- hsc3-dot -}--> draw_svg (pv_g 1024 (bpf_sweep 1024))
− Help/UGen/Filter/allpassC.help.lhs
@@ -1,1 +0,0 @@-See allPassN
− Help/UGen/Filter/allpassL.help.lhs
@@ -1,1 +0,0 @@-See allPassN
− Help/UGen/Filter/allpassN.help.lhs
@@ -1,39 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "AllpassN"-> Sound.SC3.UGen.DB.ugenSummary "AllpassN"--> import Sound.SC3--Since the allpass delay has no audible effect as a resonator on steady-state sound ...--> let {dly = xLine KR 0.0001 0.01 20 RemoveSynth->     ;n = whiteNoise 'a' AR}-> in audition (out 0 (allpassC (n * 0.1) 0.01 dly 0.2))--...these examples add the input to the effected sound so that you-can hear the effect of the phase comb.--> let {n = whiteNoise 'a' AR->     ;dly = xLine KR 0.0001 0.01 20 RemoveSynth}-> in audition (out 0 ((n + allpassN (n * 0.1) 0.01 dly 0.2) * 0.1))--Linear variant--> let {n = whiteNoise 'a' AR->     ;dly = xLine KR 0.0001 0.01 20 RemoveSynth}-> in audition (out 0 ((n + allpassL (n * 0.1) 0.01 dly 0.2) * 0.1))--Cubic variant--> let {n = whiteNoise 'a' AR->     ;dly = xLine KR 0.0001 0.01 20 RemoveSynth}-> in audition (out 0 ((n + allpassC (n * 0.1) 0.01 dly 0.2) * 0.1))--Used as an echo - doesn't really sound different than Comb, but it-outputs the input signal immediately (inverted) and the echoes are-lower in amplitude.--> let {n = whiteNoise 'a' AR->     ;d = dust 'a' AR 1->     ;src = decay (d * 0.5) 0.2 * n}-> in audition (out 0 (allpassN src 0.2 0.2 3))
− Help/UGen/Filter/bBandPass.help.lhs
@@ -1,9 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "BBandPass"-> Sound.SC3.UGen.DB.ugenSummary "BBandPass"--> import Sound.SC3--> let { i = soundIn 4->     ; f = mouseX KR 20 20000 Exponential 0.2->     ; bw = mouseY KR 0 10 Linear 0.2 }-> in audition (out 0 (bBandPass i f bw))
− Help/UGen/Filter/bBandStop.help.lhs
@@ -1,14 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "BBandStop"-> Sound.SC3.UGen.DB.ugenSummary "BBandStop"--> import Sound.SC3--> let {i = soundIn (mce2 0 1)->     ;f = mouseX KR 20 20000 Exponential 0.2->     ;bw = mouseY KR 0 10 Linear 0.2}-> in audition (out 0 (bBandStop i f bw))--> let {i = sinOsc AR 1000 (mce2 0 0)->     ;f = mouseX KR 800 1200 Exponential 0.2->     ;bw = mouseY KR 0 10 Linear 0.2}-> in audition (out 0 (bBandStop i f bw))
− Help/UGen/Filter/bHiPass.help.lhs
@@ -1,9 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "BHiPass"-> Sound.SC3.UGen.DB.ugenSummary "BHiPass"--> import Sound.SC3--> let { i = soundIn (mce2 0 1)->     ; f = mouseX KR 10 20000 Exponential 0.2->     ; rq = mouseY KR 0 1 Linear 0.2 }-> in audition (out 0 (bHiPass i f rq))
− Help/UGen/Filter/bHiShelf.help.lhs
@@ -1,14 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "BHiShelf"-> Sound.SC3.UGen.DB.ugenSummary "BHiShelf"--> import Sound.SC3--> let { i = soundIn 4->     ; f = mouseX KR 2200 18000 Exponential 0.2->     ; db = mouseY KR 18 (-18) Linear 0.2 }-> in audition (out 0 (bHiShelf i f 1 db))--> let { i = soundIn 4->     ; f = mouseX KR 2200 18000 Exponential 0.2->     ; rs = mouseY KR 0.1 1 Linear 0.2 }-> in audition (out 0 (bHiShelf i f rs 6))
− Help/UGen/Filter/bLowPass.help.lhs
@@ -1,23 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "BLowPass"-> Sound.SC3.UGen.DB.ugenSummary "BLowPass"-> :t bLowPassCoef--> import Sound.SC3.ID--> let { i = soundIn (mce2 0 1)->     ; f = mouseX KR 10 20000 Exponential 0.2->     ; rq = mouseY KR 0 1 Linear 0.2 }-> in audition (out 0 (bLowPass i f rq))--> let { i = mix (saw AR (mce [0.99, 1, 1.01] * 440) * 0.3)->     ; f = mouseX KR 100 20000 Exponential 0.2->     ; rq = mouseY KR 0.1 1 Linear 0.2 }-> in audition (out 0 (bLowPass i f rq))--Calculate coefficients and use sos.-> let { i = mix (saw AR (mce [0.99, 1, 1.01] * 440) * 0.3)->     ; f = mouseX KR 100 20000 Exponential 0.2->     ; rq = mouseY KR 0.1 1 Linear 0.2->     ; (a0, a1, a2, b1, b2) = bLowPassCoef sampleRate f rq->     ; flt ip = sos ip a0 a1 a2 b1 b2 }-> in audition (out 0 (flt (flt i)))
− Help/UGen/Filter/bLowShelf.help.lhs
@@ -1,16 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "BLowShelf"-> Sound.SC3.UGen.DB.ugenSummary "BLowShelf"--> import Sound.SC3.ID--> let { i = soundIn (mce2 0 1)->     ; f = mouseX KR 40 6000 Exponential 0.2->     ; rs = 1->     ; db = mouseY KR 24 (-24) Linear 0.2 }-> in audition (out 0 (bLowShelf i f rs db))--> let { i = soundIn (mce2 0 1)->     ; f = mouseX KR 20 6000 Exponential 0.2->     ; rs = mouseY KR 0.1 1 Linear 0.2->     ; db = 6}-> in audition (out 0 (bLowShelf i f rs db))
− Help/UGen/Filter/bPeakEQ.help.lhs
@@ -1,14 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "BPeakEQ"-> Sound.SC3.UGen.DB.ugenSummary "BPeakEQ"--> import Sound.SC3.ID--> let { i = soundIn 4->     ; f = mouseX KR 2200 18000 Exponential 0.2->     ; db = mouseY KR 12 (-12) Linear 0.2 }-> in audition (out 0 (bPeakEQ i f 0.8 db))--> let { i = soundIn 4->     ; f = mouseX KR 2200 18000 Exponential 0.2->     ; rq = mouseY KR 10 0.4 Linear 0.2 }-> in audition (out 0 (bPeakEQ i f rq 6))
− Help/UGen/Filter/bpf.help.lhs
@@ -1,12 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "BPF"-> Sound.SC3.UGen.DB.ugenSummary "BPF"--> import Sound.SC3.ID--> let f = fSinOsc KR (xLine KR 0.7 300 20 RemoveSynth) 0 * 3600 + 4000-> in audition (out 0 (bpf (saw AR 200 * 0.5) f 0.3 ))--> let { n = whiteNoise 'a' AR->     ; x = mouseX KR 220 440 Exponential 0.1->     ; y = mouseY KR 0.01 0.2 Linear 0.1 }-> in audition (out 0 (bpf n (mce [x, 550 - x]) y))
− Help/UGen/Filter/bpz2.help.lhs
@@ -1,7 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "BPZ2"-> Sound.SC3.UGen.DB.ugenSummary "BPZ2"--> import Sound.SC3.ID--> let n = whiteNoise 'a' AR-> in audition (out 0 (bpz2 (n * 0.25)))
− Help/UGen/Filter/brf.help.lhs
@@ -1,7 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "BRF"-> Sound.SC3.UGen.DB.ugenSummary "BRF"--> import Sound.SC3.ID--> let f = fSinOsc KR (xLine KR 0.7 300 20 RemoveSynth) 0 * 3800 + 4000-> in audition (out 0 (brf (saw AR 200 * 0.1) f 0.3))
− Help/UGen/Filter/changed.help.lhs
@@ -1,12 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Changed"-> Sound.SC3.UGen.DB.ugenSummary "Changed"--> import Sound.SC3.ID--simple composition of hpz1 and >*--> let {s = lfNoise0 'α' KR 2->     ;c = changed s 0->     ;c' = decay2 c 0.01 0.5->     ;o = sinOsc AR (440 + mce2 s c' * 440) 0 * 0.1}-> in audition (out 0 o)
− Help/UGen/Filter/clip.help.lhs
@@ -1,4 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Clip"-> Sound.SC3.UGen.DB.ugenSummary "Clip"--> audition (out 0 (clip (sinOsc AR 440 0 * 0.4) (-0.25) 0.25))
− Help/UGen/Filter/combC.help.lhs
@@ -1,1 +0,0 @@-See combN
− Help/UGen/Filter/combL.help.lhs
@@ -1,1 +0,0 @@-See combN
− Help/UGen/Filter/combN.help.lhs
@@ -1,32 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "CombN"-> Sound.SC3.UGen.DB.ugenSummary "CombN"--> import Sound.SC3.ID {- hsc3 -}--Comb filter as resonator. The resonant fundamental is equal to-reciprocal of the delay time.--> let {n = whiteNoise 'α' AR->     ;dt = xLine KR 0.0001 0.01 20 RemoveSynth}-> in audition (out 0 (combN (n * 0.1) 0.01 dt 0.2))--> let {n = whiteNoise 'α' AR->     ;dt = xLine KR 0.0001 0.01 20 RemoveSynth}-> in audition (out 0 (combL (n * 0.1) 0.01 dt 0.2))--> let {n = whiteNoise 'α' AR->     ;dt = xLine KR 0.0001 0.01 20 RemoveSynth}-> in audition (out 0 (combC (n * 0.1) 0.01 dt 0.2))--With negative feedback--> let {n = whiteNoise 'α' AR->     ;dt = xLine KR 0.0001 0.01 20 RemoveSynth}-> in audition (out 0 (combC (n * 0.1) 0.01 dt (-0.2)))--Used as an echo.--> let {d = dust 'α' AR 1->     ;n = whiteNoise 'β' AR->     ;i = decay (d * 0.5) 0.2 * n}-> in audition (out 0 (combC i 0.2 0.2 3))
− Help/UGen/Filter/decay.help.lhs
@@ -1,9 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Decay"-> Sound.SC3.UGen.DB.ugenSummary "Decay"--> import Sound.SC3.ID--Used as an envelope.-> let {n = pinkNoise 'a' AR->     ;s = impulse AR (xLine KR 1 50 20 RemoveSynth) 0.25}-> in audition (out 0 (decay s 0.2 * n))
− Help/UGen/Filter/decay2.help.lhs
@@ -1,16 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Decay2"-> Sound.SC3.UGen.DB.ugenSummary "Decay2"--> import Sound.SC3--Used as an envelope--> let {s = fSinOsc AR 600 0 * 0.25->     ;f = xLine KR 1 50 20 RemoveSynth}-> in audition (out 0 (decay2 (impulse AR f 0) 0.01 0.2 * s))--Compare the above with Decay used as the envelope.--> let {s = fSinOsc AR 600 0 * 0.25->     ;f = xLine KR 1 50 20 RemoveSynth}-> in audition (out 0 (decay (impulse AR f 0) 0.2 * s))
− Help/UGen/Filter/degreeToKey.help.lhs
@@ -1,20 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "DegreeToKey"-> Sound.SC3.UGen.DB.ugenSummary "DegreeToKey"--> import Sound.SC3.ID--allocate & initialise buffer zero--> withSC3 (async (b_alloc_setn1 0 0 [0,2,3.2,5,7,9,10]))--modal space, mouse x controls discrete pitch in dorian mode--> let {n = lfNoise1 'α' KR (mce [3,3.05])->     ;x = mouseX KR 0 15 Linear 0.1->     ;k = degreeToKey 0 x 12->     ;f b = let {o = sinOsc AR (midiCPS (b + k + n * 0.04)) 0 * 0.1->                ;t = lfPulse AR (midiCPS (mce [48,55])) 0.15 0.5->                ;d = rlpf t (midiCPS (sinOsc KR 0.1 0 * 10 + b)) 0.1 * 0.1->                ;m = o + d}->            in combN m 0.31 0.31 2 + m}-> in audition (out 0 ((f 48 + f 72) * 0.25))
− Help/UGen/Filter/delay1.help.lhs
@@ -1,9 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Delay1"-> Sound.SC3.UGen.DB.ugenSummary "Delay1"--> let s = impulse AR 1 0-> in audition (out 0 (s + (delay1 s)))--original, subtract delayed from original-> let z = dust 'a' AR 1000-> in audition (out 0 (mce2 z (z - delay1 z)))
− Help/UGen/Filter/delay2.help.lhs
@@ -1,7 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Delay2"-> Sound.SC3.UGen.DB.ugenSummary "Delay2"--> import Sound.SC3.ID--> let s = impulse AR 1 0-> in audition (out 0 (s + (delay2 s)))
− Help/UGen/Filter/delayC.help.lhs
@@ -1,1 +0,0 @@-See delayN
− Help/UGen/Filter/delayL.help.lhs
@@ -1,1 +0,0 @@-See delayN
− Help/UGen/Filter/delayN.help.lhs
@@ -1,19 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "DelayN"-> Sound.SC3.UGen.DB.ugenSummary "DelayN"--> import Sound.SC3.ID--Dust randomly triggers Decay to create an exponential decay envelope-for the WhiteNoise input source.  The input is mixed with the delay.-> let {d = dust 'a' AR 1->     ;n = whiteNoise 'b' AR->     ;z = decay d 0.3 * n->     ;x = mouseX KR 0.0 0.2 Linear 0.1}-> in audition (out 0 (z + delayN z 0.2 x))--The delay time can be varied at control rate.  An oscillator either-reinforcing or cancelling with the delayed copy of itself.-> let { o = sinOsc AR 320 0 * 0.1->     ; l = 0.005->     ; x = mouseX KR 0.0 l Linear 0.15 }-> in audition (out 0 (o + delayN o l x))
− Help/UGen/Filter/dynKlank.help.lhs
@@ -1,40 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "DynKlank"-> Sound.SC3.UGen.DB.ugenSummary "DynKlank"--> import Sound.SC3.ID {- hsc3 -}--{s=`[[800,1071,1153,1723],nil,[1,1,1,1]]-;DynKlank.ar(,Impulse.ar(2,0,0.1))}.play--> let s = klankSpec [800,1071,1153,1723] [1,1,1,1] [1,1,1,1]-> in audition (out 0 (dynKlank (impulse AR 2 0 * 0.1) 1 0 1 s))--{s=`[[800,1071,1353,1723],nil,[1,1,1,1]]-;DynKlank.ar(s,Dust.ar(8,0.1))}.play--> let s = klankSpec [800,1071,1353,1723] [1,1,1,1] [1,1,1,1]-> in audition (out 0 (dynKlank (dust 'α' AR 8 * 0.1) 1 0 1 s))--{s=`[[800,1071,1353,1723],nil,[1,1,1,1]]-;DynKlank.ar(s,PinkNoise.ar(0.007))}.play--> let s = klankSpec [800,1071,1353,1723] [1,1,1,1] [1,1,1,1]-> in audition (out 0 (dynKlank (pinkNoise 'α' AR * 0.007) 1 0 1 s))--{s=`[[200,671,1153,1723],nil,[1,1,1,1]]-;a=[0.007,0.007]-;DynKlank.ar(s,PinkNoise.ar(a))}.play;--> let {s = klankSpec [200,671,1153,1723] [1,1,1,1] [1,1,1,1]->     ;a = mce2 0.007 0.007}-> in audition (out 0 (dynKlank (pinkNoise 'α' AR * a) 1 0 1 s))--Change frequencies (x) and ring-times (y) with mouse.--> let {x = mouseX KR 0.5 2 Exponential 0.2->     ;f = map (* x) [800,1071,1153,1723]->     ;y = mouseY KR 0.1 10 Exponential 0.2->     ;d = map (* y) [1,1,1,1]->     ;s = klankSpec f [1,1,1,1] d->     ;i = impulse AR 2 0 * 0.1}-> in audition (out 0 (dynKlank i 1 0 1 s))
− Help/UGen/Filter/formlet.help.lhs
@@ -1,32 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Formlet"-> Sound.SC3.UGen.DB.ugenSummary "Formlet"--> import Sound.SC3.ID {- hsc3 -}--> audition (out 0 (formlet (impulse AR 20 0.5) 1000 0.01 0.1))--> let f = xLine KR 10 400 8 RemoveSynth-> in audition (out 0 (formlet (blip AR f 1000 * 0.1) 1000 0.01 0.1))--Modulating formant frequency.--> let {s = blip AR (sinOsc KR 5 0 * 20 + 300) 1000 * 0.1->     ;ff = xLine KR 1500 700 8 RemoveSynth}-> in audition (out 0 (formlet s ff 0.005 0.04))--Mouse control of frequency and decay time.--> let {s = blip AR (sinOsc KR 5 0 * 20 + 300) 1000 * 0.1->     ;x = mouseX KR 0.01 0.2 Exponential 0.2->     ;y = mouseY KR 700 2000 Exponential 0.2->     ;o = formlet s y 0.005 x}-> in audition (out 0 o)--and again...--> let {s = dust 'α' KR (mce2 10 11)->     ;x = mouseX KR 0.1 2 Exponential 0.2->     ;y = mouseY KR 7 200 Exponential 0.2->     ;f = formlet s y 0.005 x->     ;o = sinOsc AR (f * 200 + mce2 500 600 - 100) 0 * 0.2}-> in audition (out 0 o)
− Help/UGen/Filter/fos.help.lhs
@@ -1,12 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "FOS"-> Sound.SC3.UGen.DB.ugenSummary "FOS"--> import Sound.SC3.ID--Same as OnePole.-> let x = lfTri AR 0.4 0 * 0.99-> in audition (out 0 (fos (lfSaw AR 200 0 * 0.2) (1 - (abs x)) 0 x))--Same as OneZero-> let x = lfTri AR 0.4 0 * 0.99-> in audition (out 0 (fos (lfSaw AR 200 0 * 0.2) (1 - (abs x)) x 0))
− Help/UGen/Filter/freeVerb.help.lhs
@@ -1,20 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "FreeVerb"-> Sound.SC3.UGen.DB.ugenSummary "FreeVerb"--> import Sound.SC3--> let {i = impulse AR 1 0->     ;c = lfCub AR 1200 0->     ;s = decay i 0.25 * c * 0.1->     ;x = mouseX KR 0 1 Linear 0.1->     ;y = mouseY KR 0 1 Linear 0.1->     ;r = freeVerb s y x 0.5}-> in audition (out 0 r)--Process input channels-> let {i = soundIn (mce2 0 1)->     ;c = mceChannel->     ;x = mouseX KR 0 1 Linear 0.1->     ;y = mouseY KR 0 1 Linear 0.1->     ;r = freeVerb2 (c 0 i) (c 1 i) y x 0.5}-> in audition (out 0 r)
− Help/UGen/Filter/freqShift.help.lhs
@@ -1,45 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "FreqShift"-> Sound.SC3.UGen.DB.ugenSummary "FreqShift"--> import Sound.SC3.ID {- hcs3 -}--Shifting a 100Hz tone by 1 Hz rising to 500Hz--> let {i = sinOsc AR 100 0->     ;s = xLine KR 1 500 5 RemoveSynth}-> in audition (out 0 (freqShift i s 0 * 0.1))--Shifting a complex tone by 1 Hz rising to 500Hz--> let {d = klangSpec [101, 303, 606, 808] [1, 1, 1, 1] [1, 1, 1, 1]->     ;i = klang AR 1 0 d->     ;s = xLine KR 1 500 5 RemoveSynth}-> in audition (out 0 (freqShift i s 0 * 0.1))--Modulating shift and phase--> let {s = lfNoise2 'α' AR 0.3->     ;i = sinOsc AR 10 0->     ;p = linLin (sinOsc AR 500 0) (-1) 1 0 (2 * pi)}-> in audition (out 0 (freqShift i (s * 1500) p * 0.1))--Shifting bandpassed noise--> let {n1 = whiteNoise 'α' AR->     ;n2 = lfNoise0 'β' AR 5.5->     ;i = bpf n1 1000 0.001->     ;s = n2 * 1000}-> in audition (out 0 (freqShift i s 0 * 32))--{a=Blip.ar(60,4,LFGauss.ar(4,1/8))-;a=a/4+LocalIn.ar(2)-;a=FreqShift.ar(a,LFNoise0.kr(1/4,90))-;LocalOut.ar(DelayC.ar(a,1,0.1,0.9))-;a}.play--> let {e = lfGauss AR 4 (1/8) 0 Loop DoNothing->     ;o = blip AR 60 4 * e->     ;a = o / 4 + localIn 2 AR->     ;s = freqShift a (lfNoise0 'α' KR (1/4) * 90) 0->     ;z = delayC s 1 0.1 * 0.9}-> in audition (mrg2 (out 0 s) (localOut z))
− Help/UGen/Filter/gVerb.help.lhs
@@ -1,10 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "GVerb"-> Sound.SC3.UGen.DB.ugenSummary "GVerb"--> import Sound.SC3.ID--> let {i = impulse AR 1 0->     ;c = lfCub AR 1200 0->     ;s = decay i 0.25 * c * 0.1->     ;r = gVerb s 10 3 0.5 0.5 15 1 0.7 0.5 300}-> in audition (out 0 r)
− Help/UGen/Filter/hasher.help.lhs
@@ -1,12 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Hasher"-> Sound.SC3.UGen.DB.ugenSummary "Hasher"--> import Sound.SC3.ID--noise-> audition (out 0 (hasher (line AR 0 1 1 RemoveSynth) * 0.2))--remap x-> let {x = mouseX KR 0 10 Linear 0.2->     ;f = hasher (roundTo x 1) * 300 + 500}-> in audition (out 0 (sinOsc AR f 0 * 0.1))
− Help/UGen/Filter/hpf.help.lhs
@@ -1,7 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "HPF"-> Sound.SC3.UGen.DB.ugenSummary "HPF"--> import Sound.SC3.ID--> let f = fSinOsc KR (xLine KR 0.7 300 20 RemoveSynth) 0 * 3600 + 4000-> in audition (out 0 (hpf (saw AR 200 * 0.2) f))
− Help/UGen/Filter/hpz1.help.lhs
@@ -1,7 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "HPZ1"-> Sound.SC3.UGen.DB.ugenSummary "HPZ1"--> import Sound.SC3.ID--> let n = whiteNoise 'a' AR-> in audition (out 0 (hpz1 (n * 0.25)))
− Help/UGen/Filter/hpz2.help.lhs
@@ -1,7 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "HPZ2"-> Sound.SC3.UGen.DB.ugenSummary "HPZ2"--> import Sound.SC3.ID--> let n = whiteNoise 'a' AR-> in audition (out 0 (hpz2 (n * 0.25)))
− Help/UGen/Filter/klank.help.lhs
@@ -1,31 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Klank"-> Sound.SC3.UGen.DB.ugenSummary "Klank"--> import Sound.SC3 {- hsc3 -}--The function klankSpec can help create the 'spec' entry.--> let s = klankSpec' [800,1071,1153,1723] [1,1,1,1] [1,1,1,1]-> in audition (out 0 (klank (impulse AR 2 0 * 0.1) 1 0 1 s))--A variant spec function takes non-UGen inputs--> let {f = [800::Double,1071,1153,1723]->     ;u = [1,1,1,1]->     ;s = klankSpec' f u u}-> in audition (out 0 (klank (impulse AR 2 0 * 0.1) 1 0 1 s))--There is a limited form of multiple channel expansion possible at-'specification' input, below three equal dimensional specifications-are transposed and force expansion in a sensible manner.--> let {u = [1,1,1,1]->     ;p = [200,171,153,172]->     ;q = [930,971,953,1323]->     ;r = [8900,16062,9013,7892]->     ;k = mce [klankSpec' p u u,klankSpec' q u u,klankSpec' r u u]->     ;s = mceTranspose k->     ;i = mce [2,2.07,2.13]->     ;t = impulse AR i 0 * 0.1->     ;l = mce [-1,0,1]}-> in audition (out 0 (mix (pan2 (klank t 1 0 1 s) l 1)))
− Help/UGen/Filter/lag.help.lhs
@@ -1,9 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Lag"-> Sound.SC3.UGen.DB.ugenSummary "Lag"--> import Sound.SC3--used to lag pitch--> let x = mouseX KR 220 440 Linear 0.2-> in audition (out 0 (sinOsc AR (mce [x, lag x 1]) 0 * 0.1))
− Help/UGen/Filter/lag2.help.lhs
@@ -1,7 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Lag2"-> Sound.SC3.UGen.DB.ugenSummary "Lag2"--> import Sound.SC3--> let x = mouseX KR 220 440 Exponential 0.1-> in audition (out 0 (sinOsc AR (mce [x, lag2 x 1]) 0 * 0.1))
− Help/UGen/Filter/lag3.help.lhs
@@ -1,7 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Lag3"-> Sound.SC3.UGen.DB.ugenSummary "Lag3"--> import Sound.SC3--> let x = mouseX KR 220 440 Exponential 0.1-> in audition (out 0 (sinOsc AR (mce [x, lag3 x 1]) 0 * 0.1))
− Help/UGen/Filter/lagUD.help.lhs
@@ -1,10 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "LagUD"-> Sound.SC3.UGen.DB.ugenSummary "LagUD"--> import Sound.SC3--lag pitch, slower down (5 seconds) than up (1 second)--> let {x = mouseX KR 220 440 Linear 0.2->     ;o = sinOsc AR (mce2 x (lagUD x 1 5)) 0 * 0.1}-> in audition (out 0 o)
− Help/UGen/Filter/latch.help.lhs
@@ -1,21 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Latch"-> Sound.SC3.UGen.DB.ugenSummary "Latch"--> import Sound.SC3.Monadic--> do {n <- whiteNoise AR->    ;let {i = impulse AR 9 0->         ;l = latch n i}->     in audition (out 0 (blip AR (l * 400 + 500) 4 * 0.2))}--The above is just meant as example. LFNoise0 is a faster way to-generate random steps :-> do {n <- lfNoise0 KR 9->    ;audition (out 0 (blip AR (n * 400 + 500) 4 * 0.2))}--http://create.ucsb.edu/pipermail/sc-users/2006-December/029991.html-> do {n0 <- lfNoise2 KR 8->    ;n1 <- lfNoise2 KR 3->    ;let {s = blip AR (n0 * 200 + 300) (n1 * 10 + 20)->         ;x = mouseX KR 1000 (sampleRate * 0.1) Exponential 0.1}->     in audition (out 0 (latch s (impulse AR x 0)))}
− Help/UGen/Filter/leakDC.help.lhs
@@ -1,7 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "LeakDC"-> Sound.SC3.UGen.DB.ugenSummary "LeakDC"--> import Sound.SC3--> let a = lfPulse AR 800 0 0.5 * 0.1 + 0.5-> in audition (out 0 (mce [a,leakDC a 0.995]))
− Help/UGen/Filter/limiter.help.lhs
@@ -1,14 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Limiter"-> Sound.SC3.UGen.DB.ugenSummary "Limiter"--> import Sound.SC3--example signal-> let z = let i = impulse AR 8 0 * lfSaw KR 0.25 0 * (-0.6) + 0.7->         in decay2 i 0.001 0.3 * fSinOsc AR 500 0--unprocessed-> audition (out 0 z)--limited-> audition (out 0 (limiter z 0.4 0.01))
− Help/UGen/Filter/linExp.help.lhs
@@ -1,11 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "LinExp"-> Sound.SC3.UGen.DB.ugenSummary "LinExp"--> let f = linExp (mouseX KR 0 1 Linear 0.2) 0 1 440 660-> in audition (out 0 (sinOsc AR f 0 * 0.1))--The destination range may be k-rate.-> let {x = mouseX KR 0 1 Linear 0.2->     ;y = mouseY KR 220 440 Linear 0.2->     ;f = linExp x 0 1 y 660}-> in audition (out 0 (sinOsc AR f 0 * 0.1))
− Help/UGen/Filter/linLin.help.lhs
@@ -1,22 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "LinLin"-> Sound.SC3.UGen.DB.ugenSummary "LinLin"--> import Sound.SC3--> let f = linLin (mouseX KR 0 1 Linear 0.2) 0 1 440 660-> in audition (out 0 (sinOsc AR f 0 * 0.1))--The destination range may be k-rate.-> let { x = mouseX KR 0 1 Linear 0.2->     ; y = mouseY KR 220 440 Linear 0.2->     ; f = linLin x 0 1 y 660 }-> in audition (out 0 (sinOsc AR f 0 * 0.1))--> import Sound.SC3.ID--Modulating source and destination values.-> let {n = lfNoise2 'a' AR 80->     ;x = mouseX KR 200 8000 Linear 0.2->     ;y = mouseY KR 200 8000 Linear 0.2->     ;f = linLin n (sinOsc KR 0.2 0) (sinOsc KR 0.2543 0) x y}-> in audition (out 0 (sinOsc AR f 0 * 0.1))
− Help/UGen/Filter/linXFade2.help.lhs
@@ -1,12 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "LinXFade2"-> Sound.SC3.UGen.DB.ugenSummary "LinXFade2"--> import Sound.SC3.ID--> let o = linXFade2 (saw AR 440) (sinOsc AR 440 0) (lfTri KR 0.1 0) * 0.1-> in audition (out 0 o)--> let o = linXFade2 (fSinOsc AR 800 0 * 0.2)->                   (pinkNoise 'α' AR * 0.2)->                   (fSinOsc KR 1 0)-> in audition (out 0 o)
− Help/UGen/Filter/lpf.help.lhs
@@ -1,12 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "LPF"-> Sound.SC3.UGen.DB.ugenSummary "LPF"--> import Sound.SC3--> let {f = xLine KR 0.7 300 20 RemoveSynth->     ;ff = fSinOsc KR f 0 * 3600 + 4000}-> in audition (out 0 (lpf (saw AR 200 * 0.1) ff))--Control rate filtering.-> let ctl = lpf (lfPulse KR 8 0 0.5) (mouseX KR 2 50 Exponential 0.1)-> in audition (out 0 (sinOsc AR (ctl * 200 + 400) 0 * 0.1))
− Help/UGen/Filter/lpz1.help.lhs
@@ -1,7 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "LPZ1"-> Sound.SC3.UGen.DB.ugenSummary "LPZ1"--> import Sound.SC3.ID--> let n = whiteNoise 'a' AR * 0.1-> in audition (out 0 (mce2 n (lpz1 n)))
− Help/UGen/Filter/lpz2.help.lhs
@@ -1,7 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "LPZ2"-> Sound.SC3.UGen.DB.ugenSummary "LPZ2"--> import Sound.SC3.ID--> let n = whiteNoise 'a' AR-> in audition (out 0 (lpz2 (n * 0.25)))
− Help/UGen/Filter/mantissaMask.help.lhs
@@ -1,7 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "MantissaMask"-> Sound.SC3.UGen.DB.ugenSummary "MantissaMask"--> import Sound.SC3--> let s = sinOsc AR (sinOsc KR 0.2 0 * 400 + 500) 0 * 0.4-> in audition (out 0 (mantissaMask s 3))
− Help/UGen/Filter/median.help.lhs
@@ -1,22 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Median"-> Sound.SC3.UGen.DB.ugenSummary "Median"--> import Sound.SC3.ID--Signal with impulse noise.-> let n = dust2 'a' AR 100-> in audition (out 0 (median 3 (saw AR 500 * 0.1 + n * 0.9)))--The median length can be increased for longer duration noise.-> let n = dust2 'a' AR 100-> in audition (out 0 (median 5 (saw AR 500 * 0.1 + lpz1 (n * 0.9))))--Long Median filters begin chopping off the peaks of the waveform-> let x = sinOsc AR 1000 0 * 0.2-> in audition (out 0 (mce [x, median 31 x]))--Another noise reduction application. Use Median filter for high-frequency noise.  Use LeakDC for low frequency noise.-> let {n = whiteNoise 'a' AR->     ;s = median 31 (n * 0.1 + sinOsc AR 800 0 * 0.1)}-> in audition (out 0 (leakDC s 0.9))
− Help/UGen/Filter/midEQ.help.lhs
@@ -1,11 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "MidEQ"-> Sound.SC3.UGen.DB.ugenSummary "MidEQ"--> import Sound.SC3.ID--> let f = midiCPS (fSinOsc KR 1 0 * 24 + 84)-> in audition (out 0 (midEQ (saw AR 200 * 0.2) f 0.3 12))--> let {i = pinkNoise 'a' AR * 0.2 + sinOsc AR 600 0 * 0.1->     ;f = sinOsc KR 0.2 (0.5 * pi) * 2 + 600}-> in audition (out 0 (midEQ i f 0.01 (-24)))
− Help/UGen/Filter/moogFF.help.lhs
@@ -1,22 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "MoogFF"-> Sound.SC3.UGen.DB.ugenSummary "MoogFF"--> import Sound.SC3.ID--> let {n = whiteNoise 'a' AR->     ;y = mouseY KR 100 10000 Exponential 0.1->     ;x = mouseX KR 0 4 Linear 0.1}-> in audition (out 0 (moogFF (n * 0.1) y x 0))--Note distortion at high gain.-> let {x = mouseX KR 100 20000 Exponential 0.1->     ;y = mouseY KR 0.1 4.0 Linear 0.1->     ;i = mix (saw AR (mce [0.99, 1, 1.01] * 440)) * 0.3 }-> in audition (out 0 (moogFF i x y 0))--> let {n = lfNoise0 'a' KR 0.43->     ;p = pulse AR (mce [40, 121]) (mce [0.3, 0.7])->     ;f0 = linLin n 0 1 0.001 2.2->     ;f = linLin (sinOsc KR f0 0) (-1) 1 30 4200->     ;y = mouseY KR 1 4 Linear 0.1}-> in audition (out 0 (moogFF p f (0.83 * y) 0))
− Help/UGen/Filter/normalizer.help.lhs
@@ -1,9 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Normalizer"-> Sound.SC3.UGen.DB.ugenSummary "Normalizer"--> import Sound.SC3--> let {s = fSinOsc AR 500 0->     ;t = impulse AR 8 (lfSaw KR 0.25 (-0.6) * 0.7)->     ;z = decay2 t 0.001 0.3 * s}-> in audition (out 0 (mce [z, normalizer z 0.4 0.01]))
− Help/UGen/Filter/onePole.help.lhs
@@ -1,14 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "OnePole"-> Sound.SC3.UGen.DB.ugenSummary "OnePole"--> import Sound.SC3.ID--> let n = whiteNoise 'a' AR-> in audition (out 0 (onePole (n * 0.5) 0.95))--> let n = whiteNoise 'a' AR-> in audition (out 0 (onePole (n * 0.5) (-0.95)))--> let {n = whiteNoise 'a' AR->     ;c = line KR (-0.99) 0.99 10 RemoveSynth}-> in audition (out 0 (onePole (n * 0.5) c))
− Help/UGen/Filter/oneZero.help.lhs
@@ -1,14 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "OneZero"-> Sound.SC3.UGen.DB.ugenSummary "OneZero"--> import Sound.SC3.ID--> let n = whiteNoise 'a' AR-> in audition (out 0 (oneZero (n * 0.5) 0.5))--> let n = whiteNoise 'a' AR-> in audition (out 0 (oneZero (n * 0.5) (-0.5)))--> let {n = whiteNoise 'a' AR->     ;c = line KR (-0.5) 0.5 10 RemoveSynth}-> in audition (out 0 (oneZero (n * 0.5) c))
− Help/UGen/Filter/pitchShift.help.lhs
@@ -1,14 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "PitchShift"-> Sound.SC3.UGen.DB.ugenSummary "PitchShift"--> import Sound.SC3--> let {s = sinOsc AR 440 0 * 0.1->     ;r = mouseX KR 0.5 2.0 Linear 0.1->     ;d = mouseY KR 0.0 0.1 Linear 0.1}-> in audition (out 0 (pitchShift s 0.2 r d 0))--> let {s = soundIn 4->     ;pd = mouseX KR 0.0 0.1 Linear 0.1->     ;td = mouseY KR 0.0 0.1 Linear 0.1}-> in audition (out 0 (pitchShift s 0.2 (mce2 1.0 1.5) pd td))
− Help/UGen/Filter/pluck.help.lhs
@@ -1,30 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Pluck"-> Sound.SC3.UGen.DB.ugenSummary "Pluck"--> import Sound.SC3.ID {- hsc3 -}--Excitation signal is white noise, triggered twice a second with-varying OnePole coef.--> let {n = whiteNoise 'α' AR->     ;t = impulse KR 9 0->     ;x = mouseX KR (-0.999) 0.999 Linear 0.1->     ;y = mouseY KR 0.1 1 Linear 0.1->     ;dl = 1 / 440}-> in audition (out 0 (pluck (n * 0.25) t dl (dl * y) 10 x))--> import Sound.SC3.UGen.Protect {- hsc3 -}--> let {n = 50->     ;udup = uclone 'α'->     ;f = udup n (rand 'β' 0.05 0.2)->     ;p = udup n (rand 'γ' 0 1)->     ;w = udup n (whiteNoise 'δ' AR)->     ;fi = udup n (rand 'ε' 10 12)->     ;coef = rand 'ζ' 0.01 0.2->     ;l = udup n (rand 'η' (-1) 1)->     ;x = mouseX KR 60 1000 Exponential 0.1->     ;o = linLin (sinOsc KR f p) (-1) 1 x 3000->     ;i = impulse KR fi 0->     ;ks = pluck (w * 0.1) i 0.01 (1 / o) 2 coef}-> in audition (out 0 (leakDC (mix (pan2 ks l 1)) 0.995))
− Help/UGen/Filter/ramp.help.lhs
@@ -1,17 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Ramp"-> Sound.SC3.UGen.DB.ugenSummary "Ramp"--> import Sound.SC3--Used to lag pitch--> let {o = lfPulse KR 4 0 0.5 * 50 + 400->     ;l = line KR 0 1 15 DoNothing->     ;f = ramp o l}-> in audition (out 0 (sinOsc AR f 0 * 0.3))--mouse control--> let {x = mouseX KR 220 440 Exponential 0->     ;x' = ramp x (300 / 1000)}-> in audition (out 0 (sinOsc AR (mce2 x x') 0 * 0.1))
− Help/UGen/Filter/resonz.help.lhs
@@ -1,35 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Resonz"-> Sound.SC3.UGen.DB.ugenSummary "Resonz"--> import Sound.SC3.ID--> let n = whiteNoise 'α' AR-> in audition (out 0 (resonz (n * 0.5) 2000 0.1))--Modulate frequency--> let {n = whiteNoise 'α' AR->     ;f = xLine KR 1000 8000 10 RemoveSynth}-> in audition (out 0 (resonz (n * 0.5) f 0.05))--Modulate bandwidth--> let {n = whiteNoise 'α' AR->     ;bw = xLine KR 1 0.001 8 RemoveSynth}-> in audition (out 0 (resonz (n * 0.5) 2000 bw))--Modulate bandwidth opposite direction--> let {n = whiteNoise 'α' AR->     ;bw = xLine KR 0.001 1 8 RemoveSynth}-> in audition (out 0 (resonz (n * 0.5) 2000 bw))--Mouse exam (1/Q = bandwidth / center-frequency)--> let {n = pinkNoise 'α' AR->     ;m = mouseX KR 36 85 Linear 0.2 {- midi note -}->     ;w = mouseY KR 0.1 5 Linear 0.2 {- bandwidth -}->     ;f = midiCPS (floorE m) {- centre frequency -}->     ;rq = w / f {- 1/Q (reciprocal of Q) -}->     ;o = resonz (n * 0.5) f rq}-> in audition (out 0 o)
− Help/UGen/Filter/rhpf.help.lhs
@@ -1,7 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "RHPF"-> Sound.SC3.UGen.DB.ugenSummary "RHPF"--> import Sound.SC3--> let f = fSinOsc KR (xLine KR 0.7 300 20 RemoveSynth) 0 * 3600 + 4000-> in audition (out 0 (rhpf (saw AR 200 * 0.1) f 0.2))
− Help/UGen/Filter/ringz.help.lhs
@@ -1,26 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Ringz"-> Sound.SC3.UGen.DB.ugenSummary "Ringz"--> import Sound.SC3.ID--> let n = dust 'a' AR 3-> in audition (out 0 (ringz (n * 0.3) 2000 2))--> let n = whiteNoise 'a' AR-> in audition (out 0 (ringz (n * 0.005) 2000 0.5))--Modulate frequency-> let {n = whiteNoise 'a' AR->     ;f = xLine KR 100 3000 10 RemoveSynth}-> in audition (out 0 (ringz (n * 0.005) f 0.5))--> let f = xLine KR 100 3000 10 RemoveSynth-> in audition (out 0 (ringz (impulse AR 6 0.3) f 0.5))--Modulate ring time-> let rt = xLine KR 4 0.04 8 RemoveSynth-> in audition (out 0 (ringz (impulse AR 6 0.3) 2000 rt))--Modulate ring time opposite direction-> let rt = xLine KR 0.04 4 8 RemoveSynth-> in audition (out 0 (ringz (impulse AR 6 0.3) 2000 rt))
− Help/UGen/Filter/rlpf.help.lhs
@@ -1,12 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "RLPF"-> Sound.SC3.UGen.DB.ugenSummary "RLPF"--> import Sound.SC3.ID--> let {n = whiteNoise 'a' AR->     ;f = sinOsc AR 0.5 0 * 40 + 220->     ;r = rlpf n f 0.1}-> in audition (out 0 r)--> let f = fSinOsc KR (xLine KR 0.7 300 20 RemoveSynth) 0 * 3600 + 4000-> in audition (out 0 (rlpf (saw AR 200 * 0.1) f 0.2))
− Help/UGen/Filter/select.help.lhs
@@ -1,16 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Select"-> Sound.SC3.UGen.DB.ugenSummary "Select"--> import Sound.SC3--> let { n = 3/2->     ; a = mce [sinOsc AR 440 0, saw AR 440, pulse AR 440 0.1] }-> in audition (out 0 (select (lfSaw KR 1 0 * n + n) a * 0.2))--Here used as a sequencer:-> let { n = 10->     ; a = mce [517, 403, 89, 562, 816, 107, 241, 145, 90, 224]->     ; c = n / 2->     ; f = select (lfSaw KR 0.5 0 * c + c) a }-> in audition (out 0 (saw AR f * 0.2))-
− Help/UGen/Filter/selectX.help.lhs
@@ -1,21 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "SelectX"-> :t selectX--# composite ugen graph--> import Sound.SC3-> import Sound.SC3.UGen.Dot--> let { n = 3/2->     ; f = mce2 440 441->     ; a = mce [sinOsc AR f 0, saw AR f, pulse AR f 0.1]->     ; s = mceSum (selectX (lfSaw KR 1 0 * n + n) a * 0.2) }-> in audition (out 0 s) >> draw s--Here used as a sequencer:-> let { n = 10->     ; a = mce [517, 403, 89, 562, 816, 107, 241, 145, 90, 224]->     ; c = n / 2->     ; f = mceSum (selectX (lfSaw KR 0.5 0 * c + c) a)->     ; s = saw AR f * 0.2 }-> in audition (out 0 s) >> draw s
− Help/UGen/Filter/shaper.help.lhs
@@ -1,26 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Shaper"-> Sound.SC3.UGen.DB.ugenSummary "Shaper"--> import Sound.SC3--> let mk_b a = do {_ <- async (b_alloc 10 512 1)->                 ;let f = [Normalise,Wavetable,Clear]->                  in async (b_gen_cheby 10 f a)}--> let z = sinOsc AR 300 0 * line KR 0 1 6 RemoveSynth-> in withSC3 (do {_ <- mk_b [1,0,1,1,0,1]->                ;play (out 0 (shaper 10 z * 0.1))})--> let z = sinOsc AR 400 (pi / 2) * line KR 0 1 6 RemoveSynth-> in withSC3 (do {_ <- mk_b [0.25,0.5,0.25]->                ;play (out 0 (shaper 10 z * 0.1))})--> let {z = soundIn 4->     ;x = sinOsc KR (1/4) 0}-> in withSC3 (do {_ <- mk_b [1,0,1,1,0,1]->                ;play (out 0 (xFade2 z (shaper 10 z) x 0.5))})--> let {z = soundIn 4->     ;x = mouseX KR (-1) 1 Linear 0.2}-> in withSC3 (do {_ <- mk_b [1,0,1,1,0,1,0.5,0,0.25,0,0.75,1]->                ;play (out 0 (xFade2 z (shaper 10 z) x 0.5))})
− Help/UGen/Filter/slew.help.lhs
@@ -1,10 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Slew"-> Sound.SC3.UGen.DB.ugenSummary "Slew"--> import Sound.SC3--> let z = lfPulse AR 800 0 0.5 * 0.1-> in audition (out 0 (mce2 z (slew z 4000 4000)))--> let z = saw AR 800 * 0.1-> in audition (out 0 (mce2 z (slew z 400 400)))
− Help/UGen/Filter/sos.help.lhs
@@ -1,11 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "SOS"-> Sound.SC3.UGen.DB.ugenSummary "SOS"--> import Sound.SC3--Same as TwoPole-> let { theta = line KR (0.2 * pi) pi 5 RemoveSynth->     ; rho = line KR 0.6 0.99 5 RemoveSynth->     ; b1 = 2 * rho * cos theta->     ; b2 = - (rho * rho) }-> in audition (out 0 (sos (lfSaw AR 200 0 * 0.1) 1 0 0 b1 b2))
− Help/UGen/Filter/twoPole.help.lhs
@@ -1,11 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "TwoPole"-> Sound.SC3.UGen.DB.ugenSummary "TwoPole"--> import Sound.SC3.ID--> let n = whiteNoise 'a' AR-> in audition (out 0 (twoPole (n * 0.005) 2000 0.95))--> let {n = whiteNoise 'a' AR->     ;f = xLine KR 800 8000 8 RemoveSynth}-> in audition (out 0 (twoPole (n * 0.005) f 0.95))
− Help/UGen/Filter/twoZero.help.lhs
@@ -1,8 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "TwoZero"-> Sound.SC3.UGen.DB.ugenSummary "TwoZero"--> import Sound.SC3.ID--> let {n = whiteNoise 'a' AR->     ;f = xLine KR 20 20000 8 RemoveSynth}-> in audition (out 0 (twoZero (n * 0.125) f 1))
− Help/UGen/Filter/varLag.help.lhs
@@ -1,16 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "VarLag"-> Sound.SC3.UGen.DB.ugenSummary "VarLag"--#VarLag at sclang is a composite UGen, at hsc3 it's a direct binding to the underlying UGen.--> import Sound.SC3--used to lag pitch--> let x = mouseX KR 220 440 Linear 0.2-> in audition (out 0 (sinOsc AR (mce [x, varLag x 1 x]) 0 * 0.1))--compare to lag UGen--> let x = mouseX KR 220 440 Linear 0.2-> in audition (out 0 (sinOsc AR (mce [x, lag x 1]) 0 * 0.1))
− Help/UGen/Filter/wrapIndex.help.lhs
@@ -1,15 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "WrapIndex"-> Sound.SC3.UGen.DB.ugenSummary "WrapIndex"--> import Sound.SC3--> withSC3 (async (b_alloc_setn1 0 0 [200,300,400,500,600,800]))--> let {x = mouseX KR 0 18 Linear 0.1->     ;f = wrapIndex 0 x}-> in audition (out 0 (sinOsc AR f 0 * 0.1))--> let {b = asLocalBuf 'α' [200,300,400,500,600,800]->     ;x = mouseX KR 0 18 Linear 0.1->     ;f = wrapIndex b x}-> in audition (out 0 (sinOsc AR f 0 * 0.1))
− Help/UGen/Filter/xFade2.help.lhs
@@ -1,12 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "XFade2"-> Sound.SC3.UGen.DB.ugenSummary "XFade2"--> import Sound.SC3.ID--> let o = xFade2 (saw AR 440) (sinOsc AR 440 0) (lfTri KR 0.1 0) 0.1-> in audition (out 0 o)--> let o = linXFade2 (fSinOsc AR 800 0 * 0.2)->                   (pinkNoise 'α' AR * 0.2)->                   (fSinOsc KR 1 0)-> in audition (out 0 o)
− Help/UGen/Granular/grainBuf.help.lhs
@@ -1,30 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "GrainBuf"-> Sound.SC3.UGen.DB.ugenSummary "GrainBuf"--> import Sound.SC3.ID--> let fn = "/home/rohan/data/audio/pf-c5.snd"-> in withSC3 (send (b_allocRead 10 fn 0 0))--> let {buf = 10->     ;dur = 15->     ;lin a b = line KR a b dur RemoveSynth->     ;tr = impulse KR (lin 7.5 15) 0->     ;gd = lin 0.05 0.1->     ;r = lin 1 0.5 {- rate -}->     ;i = lin 0 1 {- read-location -}->     ;l = lin (-0.5) 0.5 {- stereo-location -}->     ;g = grainBuf 2 tr gd buf r i 2 l (-1) 512}-> in audition (out 0 g)--> let {b = 10->     ;e = -1->     ;x = mouseX KR (-1) 1 Linear 0.1->     ;y = mouseY KR 10 45 Linear 0.1->     ;i = impulse KR y 0->     ;n1 = lfNoise1 'α' KR 500->     ;n2 = lfNoise2 'β' KR 0.1->     ;r = linLin n1 (-1) 1 0.5 2->     ;p = linLin n2 (-1) 1 0 1->     ;g = grainBuf 2 i 0.1 b r p 2 x e 512}-> in audition (out 0 g)
− Help/UGen/Granular/grainFM.help.lhs
@@ -1,22 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "GrainFM"-> Sound.SC3.UGen.DB.ugenSummary "GrainFM"--> import Sound.SC3.ID--> let {d = 15->     ;lin a b = line KR a b d RemoveSynth->     ;l = lin (-0.5) 0.5->     ;f = lin 200 800->     ;t = impulse KR (lin 7.5 15) 0->     ;i = lin (-1) 1}-> in audition (out 0 (grainFM 2 t 0.1 f 200 i l (-1) 512 * 0.1))--> let {n1 = whiteNoise 'α' KR->     ;n2 = lfNoise1 'β' KR 500->     ;d = 5->     ;x = mouseX KR (-0.5) 0.5 Linear 0.1->     ;y = mouseY KR 0 400 Linear 0.1->     ;f = n1 * y + 440->     ;t = impulse KR 12.5 0->     ;i = linLin n2 (-1) 1 1 10}-> in audition (out 0 (grainFM 2 t 0.1 f 200 i x (-1) 512 * 0.1))
− Help/UGen/Granular/grainIn.help.lhs
@@ -1,11 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "GrainIn"-> Sound.SC3.UGen.DB.ugenSummary "GrainIn"--> import Sound.SC3.ID--> let {n = pinkNoise 'α' AR->     ;x = mouseX KR (-0.5) 0.5 Linear 0.1->     ;y = mouseY KR 5 25 Linear 0.1->     ;t = impulse KR y 0->     ;g = grainIn 2 t 0.1 n x (-1) 512 * 0.1}-> in audition (out 0 g)
− Help/UGen/Granular/grainSin.help.lhs
@@ -1,11 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "GrainSin"-> Sound.SC3.UGen.DB.ugenSummary "GrainSin"--> import Sound.SC3.ID--> let {n = whiteNoise 'α' KR->     ;x = mouseX KR (-0.5) 0.5 Linear 0.1->     ;y = mouseY KR 0 400 Linear 0.1->     ;f = n * y + 440->     ;t = impulse KR 10 0}-> in audition (out 0 (grainSin 2 t 0.1 f x (-1) 512 * 0.1))
− Help/UGen/Granular/warp1.help.lhs
@@ -1,23 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Warp1"-> Sound.SC3.UGen.DB.ugenSummary "Warp1"--> import Sound.SC3--> let {fn = "/home/rohan/data/audio/pf-c5.aif"->     ;p = linLin (lfSaw KR 0.05 0) (-1) 1 0 1->     ;x = mouseX KR 0.5 2 Linear 0.1->     ;w = warp1 1 10 p x 0.1 (-1) 8 0.1 2}-> in withSC3 (do {send (b_allocRead 10 fn 0 0)->                ;play (out 0 w)})--real-time (delayed) input--> let {i = soundIn 4->     ;r = recordBuf AR 10 0 1 0 1 Loop 1 DoNothing i->     ;ph = (8192 / sampleRate) * 2 * pi->     ;p = lfSaw KR (1 / bufDur KR 10) ph * 0.5 + 0.5->     ;x = mouseX KR 0.5 2 Linear 0.2->     ;y = mouseY KR 0.01 0.2 Linear 0.2->     ;w = warp1 1 10 p x 0.1 (-1) 8 y 4}-> in withSC3 (do {send (b_alloc 10 8192 1)->                ;play (out 0 (mrg2 (i + w) r))})
− Help/UGen/IO/in.help.lhs
@@ -1,53 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "In"-> Sound.SC3.UGen.DB.ugenSummary "In"--# hsc3 renames UGen to in' since in is a reserved keyword--> import Sound.SC3.ID--Patching input to output (see also soundIn).--> audition (out 0 (in' 2 AR numOutputBuses))--Patching input to output, with delay.--> let {i = in' 2 AR numOutputBuses->     ;d = delayN i 0.5 0.5}-> in audition (out 0 (i + d))--Write noise to first private bus, then read it out.-The multiple root graph is ordered.--> let {n = pinkNoise 'α' AR->     ;b = numOutputBuses + numInputBuses->     ;wr = out b (n * 0.3)->     ;rd = out 0 (in' 1 AR b)}-> in audition (mrg [rd,wr])--There are functions to encapsulate the offset calculation.-(There is also a firstPrivateBus value.)--> let {n = pinkNoise 'α' AR->     ;wr = privateOut 0 (n * 0.3)->     ;rd = out 0 (privateIn 1 AR 0)}-> in audition (mrg [rd,wr])--Set value on a control bus--> withSC3 (send (c_set1 0 300))--Read a control bus--> audition (out 0 (sinOsc AR (in' 1 KR 0) 0 * 0.1))--Re-set value on bus--> withSC3 (send (c_set1 0 600))--Control rate graph writing buses 0 & 1.--> audition (out 0 (mce2 (tRand 'α' 220 2200 (dust 'β' KR 1)) (dust 'γ' KR 3)))--Audio rate graph reading control buses 0 & 1.--> audition (out 0 (sinOsc AR (in' 1 KR 0) 0 * decay (in' 1 KR 1) 0.2 * 0.1))
− Help/UGen/IO/inFeedback.help.lhs
@@ -1,39 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "InFeedback"-> Sound.SC3.UGen.DB.ugenSummary "InFeedback"--> import Sound.SC3--Audio feedback modulation--> let {f = inFeedback 1 0 * 1300 + 300->     ;s = sinOsc AR f 0 * 0.4}-> in audition (out 0 s)--Evaluate these in either order and hear both tones.--> let {b = firstPrivateBus->     ;s = inFeedback 1 b}-> in audition (out 0 s)--> let {b  = firstPrivateBus->     ;s0 = out b (sinOsc AR 220 0 * 0.1)->     ;s1 = out 0 (sinOsc AR 660 0 * 0.1)}-> in audition (mrg [s0, s1])--Doubters consult this--> let {b = firstPrivateBus->     ;s = in' 1 AR b}-> in audition (out 0 s)--Resonator, see localOut for variant.--> let {b = firstPrivateBus->     ;p = inFeedback 1 b->     ;i = impulse AR 1 0->     ;d = delayC (i + (p * 0.995)) 1 (recip 440 - recip controlRate)}-> in audition (mrg [offsetOut b d, offsetOut 0 p])--Compare with oscillator.--> audition (out 1 (sinOsc AR 440 0 * 0.2))
− Help/UGen/IO/inTrig.help.lhs
@@ -1,14 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "InTrig"-> Sound.SC3.UGen.DB.ugenSummary "InTrig"--> import Sound.SC3--Run an oscillator with the trigger at bus 10.--> let {t = inTrig 1 10->     ;e = envGen KR t t 0 1 DoNothing (envPerc 0.01 1)}-> in audition (out 0 (sinOsc AR 440 0 * e))--Set bus 10, each set will trigger a ping.--> withSC3 (send (c_set1 10 0.1))
− Help/UGen/IO/keyState.help.lhs
@@ -1,9 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "KeyState"-> Sound.SC3.UGen.DB.ugenSummary "KeyState"--> import Sound.SC3--The keycode 38 is the A key on my keyboard.  Under X the xev(1)-command is useful in determining your keyboard layout.--> audition (out 0 (sinOsc AR 800 0 * keyState KR 38 0 0.1 0.5))
− Help/UGen/IO/lagIn.help.lhs
@@ -1,16 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "LagIn"-> Sound.SC3.UGen.DB.ugenSummary "LagIn"--> import Sound.SC3--Set frequency at control bus--> withSC3 (send (c_set1 10 200))--Oscillator reading frequency at control bus--> audition (out 0 (sinOsc AR (lagIn 1 10 1) 0 * 0.1))--Re-set frequency at control bus--> withSC3 (send (c_set1 10 2000))
− Help/UGen/IO/localBuf.help.lhs
@@ -1,75 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "LocalBuf"-> Sound.SC3.UGen.DB.ugenSummary "LocalBuf"--> import Sound.SC3.ID--Allocate a buffer local to the synthesis graph.--> let {n = whiteNoise 'α' AR->     ;b = localBuf 'β' 2048 1->     ;f = fft' b n->     ;c = pv_BrickWall f (sinOsc KR 0.1 0 * 0.75)}-> in audition (out 0 (ifft' c * 0.1))--> import Sound.SC3.UGen.Protect--Variant with two local buffers--> let {n = uclone 'α' 2 (whiteNoise 'β' AR)->     ;b = uclone 'γ' 2 (localBuf 'δ' 2048 1)->     ;f = fft' b n->     ;c = pv_BrickWall f (sinOsc KR (mce2 0.1 0.11) 0 * 0.75)}-> in audition (out 0 (ifft' c * 0.1))--Not clearing the buffer accesses old data, slowly overwrite data with noise--> let {b = localBuf 'α' 2048 2->     ;nf = bufFrames KR b->     ;x = mouseX KR 1 2 Linear 0.2->     ;r = playBuf 2 AR b x 1 0 Loop DoNothing * 0.1->     ;wr p i = bufWr b (linLin p (-1) 1 0 nf) Loop i->     ;n = uclone 'β' 2 (whiteNoise 'γ' AR)->     ;ph = lfNoise0 'δ' AR 530}-> in audition (mrg2 (out 0 r) (wr ph n))--bufCombC needs no clearing, because the delay line is filled by the ugen--> let {d = uclone 'α' 2 (dust 'β' AR 1)->     ;n = whiteNoise 'γ' AR->     ;z = decay d 0.3 * n->     ;l = xLine KR 0.0001 0.01 20 DoNothing->     ;sr = sampleRate->     ;b = uclone 'δ' 2 (localBuf 'ε' sr 2)}-> in audition (out 0 (bufCombC b z l 0.2))--asLocalBuf combines localBuf and setBuf--> let {b = asLocalBuf 'α' [2,1,5,3,4,0]->     ;x = mouseX KR 0 (bufFrames KR b) Linear 0.2->     ;f = indexL b x * 100 + 40->     ;o = saw AR (f * mce2 1 1.1) * 0.1}-> in audition (out 0 o)--detectIndex example using local buffer--> let {b = asLocalBuf 'α' [2,3,4,0,1,5]->     ;n = bufFrames KR b->     ;x = floorE (mouseX KR 0 n Linear 0.1)->     ;i = detectIndex b x}-> in audition (out 0 (sinOsc AR (linExp i 0 n 200 700) 0 * 0.1))--degreeToKey example ('modal space') using local buffer--> let {n = lfNoise1 'α' KR (mce [3,3.05])->     ;x = mouseX KR 0 15 Linear 0.1->     ;b = asLocalBuf 'β' [0,2,3.2,5,7,9,10]->     ;k = degreeToKey b x 12->     ;mk_c bf = let {f0 = midiCPS (bf + k + n * 0.04)->                    ;o = sinOsc AR f0 0 * 0.1->                    ;f1 = midiCPS (mce [48,55])->                    ;t = lfPulse AR f1 0.15 0.5->                    ;f2 = midiCPS (sinOsc KR 0.1 0 * 10 + bf)->                    ;d = rlpf t f2 0.1 * 0.1->                    ;m = o + d}->                 in combN m 0.31 0.31 2 + m}-> in audition (out 0 ((mk_c 48 + mk_c 72) * 0.25))
− Help/UGen/IO/localOut.help.lhs
@@ -1,15 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "LocalOut"-> Sound.SC3.UGen.DB.ugenSummary "LocalOut"--> import Sound.SC3.ID--Resonator, must subtract blockSize for correct tuning--> let {p = localIn 1 AR->     ;i = impulse AR 1 0->     ;d = delayC (i + (p * 0.995)) 1 (recip 440 - recip controlRate)}-> in audition (mrg [offsetOut 0 p,localOut d])--Compare with oscillator.--> audition (out 1 (sinOsc AR 440 0 * 0.2))
− Help/UGen/IO/mouseButton.help.lhs
@@ -1,12 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "MouseButton"-> Sound.SC3.UGen.DB.ugenSummary "MouseButton"--> import Sound.SC3--As amplitude envelope--> audition (out 0 (sinOsc AR 800 0 * mouseButton KR 0 0.1 0.1))--There is a variant that randomly presses the button.--> audition (out 0 (sinOsc AR 800 0 * mouseButton' KR 0 0.1 0.1))
− Help/UGen/IO/mouseX.help.lhs
@@ -1,14 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "MouseX"-> Sound.SC3.UGen.DB.ugenSummary "MouseX"--> import Sound.SC3--Frequency control--> let x = mouseX KR 40 10000 Exponential 0.2-> in audition (out 0 (sinOsc AR x 0 * 0.1))--There is a variant with equal arguments but random traversal.--> let x = mouseX' KR 40 10000 Exponential 0.2-> in audition (out 0 (sinOsc AR x 0 * 0.1))
− Help/UGen/IO/mouseY.help.lhs
@@ -1,16 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "MouseY"-> Sound.SC3.UGen.DB.ugenSummary "MouseY"--> import Sound.SC3--Frequency at X axis and amplitude at Y axis.--> let {freq = mouseX KR 20 2000 Exponential 0.1->     ;ampl = mouseY KR 0.01 0.1 Linear 0.1}-> in audition (out 0 (sinOsc AR freq 0 * ampl))--There is a variant with equal arguments but a random traversal.--> let {freq = mouseX' KR 20 2000 Exponential 0.1->     ;ampl = mouseY' KR 0.01 0.1 Linear 0.1}-> in audition (out 0 (sinOsc AR freq 0 * ampl))
− Help/UGen/IO/offsetOut.help.lhs
@@ -1,31 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "OffsetOut"-> Sound.SC3.UGen.DB.ugenSummary "OffsetOut"--> import Sound.SC3--> let {a = offsetOut 0 (impulse AR 5 0)->     ;b = out 0 (sinOsc AR 60 0 * 0.1)}-> in audition (mrg [a,b])--> let {a = out 0 (impulse AR 5 0)->     ;b = out 0 (sinOsc AR 60 0 * 0.1) }-> in audition (mrg [a,b])--> import Sound.OSC--Phase cancellation, the 'offsetOut' at bus 0 cancels, the 'out'-at bus 1 doesn't (or at least is exceedingly unlikely to).--> let a = do->       {t <- time->       ;sr <- serverSampleRateActual->       ;let {f = sr / 100->            ;c = 1 / f->            ;g = let o = sinOsc AR (constant f) 0 * 0.2->                 in synthdef "g" (mrg [offsetOut 0 o,out 1 o])->            ;m = s_new "g" (-1) AddToTail 1 []->            ;p = bundle (t + 0.1) [m]->            ;q = bundle (t + 0.1 + c/2) [m]}->       ;_ <- async (d_recv g)->       ;mapM_ sendBundle [p,q]}-> in withSC3 a
− Help/UGen/IO/out.help.lhs
@@ -1,13 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Out"-> Sound.SC3.UGen.DB.ugenSummary "Out"--> import Sound.SC3--Oscillators at outputs zero (330) and one (331)--> audition (out 0 (sinOsc AR (mce2 330 331) 0 * 0.1))--out is summing, as opposed to replaceOut--> audition (mrg [out 0 (sinOsc AR (mce2 330 990) 0 * 0.1)->               ,out 0 (sinOsc AR (mce2 331 991) 0 * 0.1)])
− Help/UGen/IO/replaceOut.help.lhs
@@ -1,29 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "ReplaceOut"-> Sound.SC3.UGen.DB.ugenSummary "ReplaceOut"--> import Sound.SC3.ID--> audition (replaceOut 0 (sinOsc AR 440 0 * 0.1))--Send signal to a bus, overwrite existing signal.--> let {a = out 0 (sinOsc AR (mce [330, 331]) 0 * 0.1)->     ;b = replaceOut 0 (sinOsc AR (mce [880, 881]) 0 * 0.1)->     ;c = out 0 (sinOsc AR (mce [120, 121]) 0 * 0.1)}-> in audition (mrg [a, b, c])--Compare to--> let {a = out 0 (sinOsc AR (mce [330, 331]) 0 * 0.1)->     ;b = out 0 (sinOsc AR (mce [880, 881]) 0 * 0.1)->     ;c = out 0 (sinOsc AR (mce [120, 121]) 0 * 0.1)}-> in audition (mrg [a, b, c])--a writes noise to 24-b reads 24 and replaces with filtered variant-c reads 24 and writes to 0--> let {a = out 24 (pinkNoise 'a' AR * 0.1)->     ;b = replaceOut 24 (bpf (in' 1 AR 24) 440 1)->     ;c = out 0 (in' 1 AR 24)}-> in mapM_ audition [a,b,c]
− Help/UGen/IO/soundIn.help.lhs
@@ -1,21 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "SoundIn"--# composite of in' and numOutputBuses--> import Sound.SC3--Copy 5th input channel (index 4) to 1st output channel (index 0).--> audition (out 0 (soundIn 4))--Copy input from 4 & 5 to 0 & 1.--> audition (out 0 (soundIn (mce2 4 5)))--IO matrix:    0 1 2 3-            0 *-            1     *-            2   *-            3       *--> audition (out 0 (soundIn (mce [0, 2, 1, 3])))
− Help/UGen/IO/xOut.help.lhs
@@ -1,14 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "XOut"-> Sound.SC3.UGen.DB.ugenSummary "XOut"--> import Sound.SC3--Send signal to a bus, crossfading with existing contents.--> let {p a b = sinOsc AR (mce [a, b]) 0 * 0.1->     ;x = mouseX KR 0 1 Linear 0.1->     ;y = mouseY KR 0 1 Linear 0.1}-> in audition (mrg [out  0   (p 220 221)->                  ,xOut 0 x (p 330 331)->                  ,xOut 0 y (p 440 441)->                  ,out  0   (p 120 121)])
− Help/UGen/Information/controlDur.help.lhs
@@ -1,9 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "ControlDur"-> Sound.SC3.UGen.DB.ugenSummary "ControlDur"--> import Sound.SC3--controlRate and controlDur are reciprocals--> let f = mce2 controlRate (recip controlDur)-> in audition (out 0 (sinOsc AR f 0 * 0.1))
− Help/UGen/Information/controlRate.help.lhs
@@ -1,9 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "ControlRate"-> Sound.SC3.UGen.DB.ugenSummary "ControlRate"--> import Sound.SC3--play a sine tone at control rate, the reciprocal of controlDur--> let f = mce2 controlRate (recip controlDur)-> in audition (out 0 (sinOsc AR f 0 * 0.1))
− Help/UGen/Information/numAudioBuses.help.lhs
@@ -1,3 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "NumAudioBuses"-> Sound.SC3.UGen.DB.ugenSummary "NumAudioBuses"-
− Help/UGen/Information/numBuffers.help.lhs
@@ -1,10 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "NumBuffers"-> Sound.SC3.UGen.DB.ugenSummary "NumBuffers"--> import Sound.SC3--the number of audio buffers available at the server (by default 1024)-> audition (poll (impulse KR 1 0) numBuffers (label "numBuffers") 0)--> let f = 110 + numBuffers-> in audition (out 0 (sinOsc AR f 0 * 0.1))
− Help/UGen/Information/numControlBuses.help.lhs
@@ -1,2 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "NumControlBuses"-> Sound.SC3.UGen.DB.ugenSummary "NumControlBuses"
− Help/UGen/Information/numInputBuses.help.lhs
@@ -1,2 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "NumInputBuses"-> Sound.SC3.UGen.DB.ugenSummary "NumInputBuses"
− Help/UGen/Information/numOutputBuses.help.lhs
@@ -1,2 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "NumOutputBuses"-> Sound.SC3.UGen.DB.ugenSummary "NumOutputBuses"
− Help/UGen/Information/numRunningSynths.help.lhs
@@ -1,7 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "NumRunningSynths"-> Sound.SC3.UGen.DB.ugenSummary "NumRunningSynths"--> import Sound.SC3--each concurrent audition increases oscillator frequency-> audition (out 0 (sinOsc AR (numRunningSynths * 200 + 400) 0 * 0.1))
− Help/UGen/Information/poll.help.lhs
@@ -1,14 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Poll"-> Sound.SC3.UGen.DB.ugenSummary "Poll"--> import Sound.SC3.ID {- hsc3 -}--> let {t = impulse KR 10 0->     ;l = line KR 0 1 1 RemoveSynth}-> in audition (poll t l (label "polling...") 0)--multichannel expansion (requires labels be equal length...)--> let {t = impulse KR (mce2 10 5) 0->     ;l = line KR 0 (mce2 1 5) (mce2 1 2) DoNothing}-> in audition (poll t l (mce2 (label "t1") (label "t2")) 0)
− Help/UGen/Information/radiansPerSample.help.lhs
@@ -1,8 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "RadiansPerSample"-> Sound.SC3.UGen.DB.ugenSummary "RadiansPerSample"--> import Sound.SC3--two pi divided by the nominal sample rate (ie. a very small number)-> let f = mce2 radiansPerSample ((2 * pi) / sampleRate) * 5e6-> in audition (out 0 (sinOsc AR f 0 * 0.1))
− Help/UGen/Information/sampleDur.help.lhs
@@ -1,9 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "SampleDur"-> Sound.SC3.UGen.DB.ugenSummary "SampleDur"--> import Sound.SC3--the reciprocal of the nominal sample rate of the server--> let f = mce2 sampleRate (recip sampleDur) * 0.01-> in audition (out 0 (sinOsc AR f 0 * 0.1))
− Help/UGen/Information/sampleRate.help.lhs
@@ -1,17 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "SampleRate"-> Sound.SC3.UGen.DB.ugenSummary "SampleRate"--> import Sound.SC3--the current nominal sample rate of the server--> let {sr = 48000 {- 44100 -}->     ;f = mce2 sampleRate sr * 0.01}-> in audition (out 0 (sinOsc AR f 0 * 0.1))--The server status command can extract nominal and actual sample rates-from a running server.--> import Control.Monad--> withSC3 (liftM2 (,) serverSampleRateNominal serverSampleRateActual)
− Help/UGen/Information/subsampleOffset.help.lhs
@@ -1,30 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "SubsampleOffset"-> Sound.SC3.UGen.DB.ugenSummary "SubsampleOffset"--> import Sound.OSC-> import Sound.SC3--Impulse train that can be moved between samples-> let g = let {a = control KR "a" 0->             ;i = impulse AR 2000 0 * 0.3->             ;d = sampleDur->             ;x = 4->             ;o = (1 - subsampleOffset) + mouseX KR 0 a Linear 0.1->             ;r = delayC i (d * (1 + x)) (d * (o + x))}->         in (synthdef "s" (offsetOut 0 r))--Create two pulse trains one sample apart, move one relative to the-other.  When cursor is at the left, the impulses are adjacent, on the-right, they are exactly 1 sample apart.  View this with an-oscilloscope.-> let run s = do->       {_ <- async (d_recv s)->       ;t <- time->       ;sr <- serverSampleRateActual->       ;let {t' = t + 0.2->            ;dt = 1 / sr->            ;m n = s_new "s" (-1) AddToTail 1 [("a", n)]}->        in do {sendBundle (bundle t' [m 3])->              ;sendBundle (bundle (t' + dt) [m 0]) }}--> withSC3 (run g)
− Help/UGen/MachineListening/beatTrack.help.lhs
@@ -1,15 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "BeatTrack"-> Sound.SC3.UGen.DB.ugenSummary "BeatTrack"--> import Sound.SC3--> let { i = soundIn 0->     ; x = mouseX KR (-1) 1 Linear 0.2->     ; MCE [b, h, q, t] = beatTrack (fft' 10 i) x->     ; f = mce [440, 660, 880]->     ; a = mce [0.4, 0.2, 0.1]->     ; s = mix (sinOsc AR f 0 * a * decay (mce [b, h, q]) 0.05) }-> in withSC3 (do {_ <- async (b_alloc 10 1024 1)->                ;play (out 0 (i + s))})--
− Help/UGen/MachineListening/loudness.help.lhs
@@ -1,14 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Loudness"-> Sound.SC3.UGen.DB.ugenSummary "Loudness"--> import Sound.SC3--Assume hop of half fftsize-> withSC3 (async (b_alloc 10 1024 1))--> let { x = mouseX KR 0.001 0.1 Exponential 0.2->     ; i = sinOsc AR 1000 0 * x->     ; f = fft' 10 i->     ; l = loudness f 0.25 6->     ; o = sinOsc AR (mce2 900 (l * 300 + 600)) 0 * 0.1 }-> in audition (out 0 o)
− Help/UGen/MachineListening/onsets.help.lhs
@@ -1,34 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Onsets"-> Sound.SC3.UGen.DB.ugenSummary "Onsets"--> import Sound.SC3.ID--allocate buffer 10-> withSC3 (async (b_alloc 10 512 1))--> let { x = mouseX KR 0 1 Linear 0.2->     ; i = soundIn 4->     ; c = fft' 10 i->     ; o = onsets' c x (onsetType "rcomplex")->     ; s = sinOsc AR 440 0 * 0.2->     ; e = envGen KR o 1 0 1 DoNothing (envPerc 0.001 0.1) }-> in audition (out 0 (s * e))--> audition (out 0 (soundIn 0 * 0.1))--a generative signal with distinct onsets!-> let z = let {e = linLin (saw AR 2) (-1) 1 0 1->             ;p = let f = midiCPS (tIRand 'a' 63 75 (impulse KR 2 0))->                  in pulse AR f 0.5->             ;f = linExp (lfNoise2 'a' KR 0.5) (-1) 1 100 10000}->         in lpf p f * e--> audition (out 0 z)--x varies threshold, whitenoise bursts indicate detected onsets-> let {c = fft' 10 z->     ;x = mouseX KR 0 1 Linear 0.2->     ;o = onsets' c x (onsetType "rcomplex")->     ;p = let d = envPerc 0.001 0.1->          in whiteNoise 'a' AR * envGen KR o 0.2 0 1 DoNothing d}-> in audition (out 0 (pan2 z (-0.75) 0.2 + pan2 p 0.75 1))
− Help/UGen/MachineListening/specCentroid.help.lhs
@@ -1,14 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "SpecCentroid"-> Sound.SC3.UGen.DB.ugenSummary "SpecCentroid"--> import Sound.SC3--as the number of harmonics increases, the centroid is pushed higher-> let {f0 = mouseY KR 1000 100 Exponential 0.2->     ;nh = mouseX KR 1 100 Exponential 0.2->     ;z = blip AR f0 nh->     ;f = fft' (localBuf 'α' 2048 1) z->     ;c = specCentroid f->     ;p = poll' (impulse KR 1 0) c (label "c") 0->     ;o = sinOsc AR p 0 * 0.1}-> in audition (out 0 o)
− Help/UGen/MachineListening/specFlatness.help.lhs
@@ -1,13 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "SpecFlatness"-> Sound.SC3.UGen.DB.ugenSummary "SpecFlatness"--> import Sound.SC3.ID--> let {z = soundIn 4->     ;g = 1 {- gain, set as required -}->     ;a = wAmp KR z 0.05->     ;f = fft' (localBuf 'α' 2048 1) z->     ;c = poll' 1 (specCentroid f) (label "c") 0->     ;w = poll' 1 (specFlatness f) (label "w") 0->     ;o = bpf (pinkNoise 'a' AR) c w * a * g}-> in audition (out 0 o)
− Help/UGen/Math/abs.help.lhs
@@ -1,6 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Operator.abs"-> :t abs--> import Sound.SC3--> audition (out 0 (abs (syncSaw AR 100 440 * 0.1)))
− Help/UGen/Math/absDif.help.lhs
@@ -1,9 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Operator.absdif"-> :t absDif--> import Sound.SC3--Finding the magnitude of the difference of two values is a common operation.-> let {p = fSinOsc AR 440 0->     ;q = fSinOsc AR 2 0 * 0.5}-> in audition (out 0 (p * 0.2 `absDif` q))
− Help/UGen/Math/add.help.lhs
@@ -1,11 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Operator.+"-> :t (+)--> import Sound.SC3.ID--> let { o = fSinOsc AR 800 0->     ; n = pinkNoise 'a' AR }-> in audition (out 0 ((o + n) * 0.1))--DC offset.-> audition (out 0 ((fSinOsc AR 440 0 * 0.1) + 0.5))
− Help/UGen/Math/amClip.help.lhs
@@ -1,7 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Operator.amclip"-> :t amClip--> import Sound.SC3.ID--> let n = whiteNoise 'a' AR-> in audition (out 0 (amClip n (fSinOsc KR 1 0 * 0.2)))
− Help/UGen/Math/atan2.help.lhs
@@ -1,16 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Operator.atan2"-> :t atan2--> import Sound.SC3--Add a pan to the hypot doppler examples by using atan2 to find the-azimuth, or direction angle, of the sound source.  Assume speakers-at +/- 45 degrees and clip the direction to between those.-> let { x = 10->     ; y = lfSaw KR (1 / 6) 0 * 100->     ; d = hypot x y->     ; a = 40 / (squared d)->     ; s = rlpf (fSinOsc AR 200 0 * lfPulse AR 31.3 0 0.4) 400 0.3->     ; z = atan2E y x->     ; l = clip2 (z / (pi / 2)) 1 }-> in audition (out 0 (pan2 (delayL s (110 / 344) (d / 344)) l a))
− Help/UGen/Math/clip2.help.lhs
@@ -1,10 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Operator.clip2"-> :t clip2--> import Sound.SC3--clipping distortion-> audition (out 0 (clip2 (fSinOsc AR 400 0) 0.2))--> let l = line KR 0 1 8 RemoveSynth-> in audition (out 0 (clip2 (fSinOsc AR 400 0) l))
− Help/UGen/Math/dbAmp.help.lhs
@@ -1,12 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Operator.dbamp"-> :t dbAmp--> import Sound.SC3--Linear db motion is exponential amplitude decay-> let {a = dbAmp (line KR (-6) (-40) 10 RemoveSynth)->     ;o = fSinOsc AR 800 0 * a}-> in audition (out 0 o)--There is a non-UGen variant.-> dbAmp (-26::Double)
− Help/UGen/Math/difSqr.help.lhs
@@ -1,13 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Operator.difsqr"-> :t difSqr--> import Sound.SC3--> let { a = fSinOsc AR 800 0->     ; b = fSinOsc AR (xLine KR 200 500 5 DoNothing) 0 }-> in audition (out 0 (difSqr a b * 0.125))--Written out:-> let { a = fSinOsc AR 800 0->     ; b = fSinOsc AR (xLine KR 200 500 5 DoNothing) 0 }-> in audition (out 0 ((a * a - b * b) * 0.125))
− Help/UGen/Math/distort.help.lhs
@@ -1,8 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Operator.distort"-> :t distort--> import Sound.SC3--> let {e = xLine KR 0.1 10 10 DoNothing->     ;o = fSinOsc AR 500 0.0}-> in audition (out 0 (distort (o * e) * 0.25))
− Help/UGen/Math/eq.help.lhs
@@ -1,2 +0,0 @@-See gt (>)-
− Help/UGen/Math/excess.help.lhs
@@ -1,13 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Operator.excess"-> :t excess--> import Sound.SC3--> let { o = fSinOsc AR 1000 0->     ; l = line KR 0 1 8 DoNothing }-> in audition (out 0 (excess o l))--or written out in terms of clip2-> let { o = fSinOsc AR 1000 0->     ; l = line KR 0 1 8 DoNothing }-> in audition (out 0 (o - (clip2 o l)))
− Help/UGen/Math/fdiv.help.lhs
@@ -1,8 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Operator./"-> :t (/)--> import Sound.SC3.ID--> let { o = fSinOsc KR 10 0.5->     ; n = pinkNoise 'a' AR }-> in audition (out 0 ((n * 0.1) / (o * 0.75)))
− Help/UGen/Math/fold2.help.lhs
@@ -1,8 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Operator.fold2"-> :t fold2--> import Sound.SC3--> let { o = fSinOsc AR 1000 0->     ; l = line KR 0 1 8 DoNothing }-> in audition (out 0 (fold2 o l))
− Help/UGen/Math/gt.help.lhs
@@ -1,20 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Operator.=="-> :t (==*)--The star suffixes (<*,<=*,>*,>=*) are because the result of the-operators is not of type Bool, as is required by the signature for the-class Ord.--> import Sound.SC3--> let { o = sinOsc KR 1 0->     ; t = [o >* 0->           ,o >=* 0->           ,o <* 0->           ,o <=* 0->           ,o ==* 0->           ,(o <* 0.001) * (o >* (-0.001))]->     ; f = [220, 330, 440, 550, 660, 770]->     ; p = envPerc 0.01 1->     ; e = envGen KR (mce t) 0.1 0 1 DoNothing p }-> in audition (out 0 (mix (sinOsc AR (mce f) 0 * e)))
− Help/UGen/Math/hypot.help.lhs
@@ -1,25 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Operator.hypot"-> :t hypot--> import Sound.SC3--> let { x = mouseX KR 0 0.1 Linear 0.1->     ; y = mouseY KR 0 0.1 Linear 0.1 }-> in audition (out 0 (sinOsc AR 440 0 * hypot x y))--Object travels 200 meters in 6 secs (=120kph) passing 10 meters-from the listener.  The speed of sound is 344 meters/sec.-> let { x = 10->     ; y = lfSaw KR (1 / 6) 0 * 100->     ; d = hypot x y->     ; v = slope d->     ; r = (344 - v) / 344->     ; a = 10 / (squared d) }-> in audition (out 0 (fSinOsc AR (1000 * r) 0 * a))--> let { x = 10->     ; y = lfSaw KR (1 / 6) 0 * 100->     ; d = hypot x y->     ; a = 40 / (squared d)->     ; s = rlpf (fSinOsc AR 200 0 * lfPulse AR 31.3 0 0.4) 400 0.3 }-> in audition (out 0 (delayL s (110 / 344) (d / 344) * a))
− Help/UGen/Math/max.help.lhs
@@ -1,9 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Operator.max"-> :t max--> import Sound.SC3--q modulates and envelopes p-> let { p = fSinOsc AR 500 0 * 0.25->     ; q = fSinOsc AR 0.5 0 }-> in audition (out 0 (p `max` q))
− Help/UGen/Math/mod.help.lhs
@@ -1,6 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Operator.%"-> :t modE--> import Sound.SC3--> audition (out 0 (fSinOsc AR 100 4 `modE` 1))
− Help/UGen/Math/mul.help.lhs
@@ -1,15 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Operator.*"-> :t (*)--> import Sound.SC3.ID--> audition (out 0 (sinOsc AR 440 0 * 0.5))--Creates a beating effect (subaudio rate).-> let n = pinkNoise 'a' AR-> in audition (out 0 (fSinOsc kr 10 0 * n * 0.5))--Ring modulation.-> let { p = sinOsc AR (xLine KR 100 1001 10 DoNothing) 0->     ; q = syncSaw AR 100 200 }-> in audition (out 0 (p * q * 0.25))
− Help/UGen/Math/pow.help.lhs
@@ -1,17 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Operator.**"-> :t (**)--> import Sound.SC3.Monadic--> let a = fSinOsc AR 100 0 * 0.1-> in audition (out 0 (mce2 a (a ** 10)))--http://create.ucsb.edu/pipermail/sc-users/2006-December/029998.html-> do { n0 <- lfNoise2 KR 8->    ; n1 <- lfNoise2 KR 3->    ; let { s = blip AR (n0 * 200 + 300) (n1 * 10 + 20)->          ; x = mouseX KR 1000 (sampleRate * 0.5) Exponential 0.1->          ; y = mouseY KR 1 24 Exponential 0.1->          ; d = latch s (impulse AR x 0)->          ; b = roundUp d (0.5 ** y) }->      in audition (out 0 (mce2 d b)) }
− Help/UGen/Math/ring1.help.lhs
@@ -1,13 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Operator.ring1"-> :t ring1--> import Sound.SC3--> let { a = fSinOsc AR 800 0->     ; b = fSinOsc AR (xLine KR 200 500 5 DoNothing) 0 }-> in audition (out 0 (ring1 a b * 0.125))--is equivalent to:-> let { a = fSinOsc AR 800 0->     ; b = fSinOsc AR (xLine KR 200 500 5 DoNothing) 0 }-> in audition (out 0 (((a * b) + a) * 0.125))
− Help/UGen/Math/roundUp.help.lhs
@@ -1,11 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Operator.round"-> :t roundUp--> import Sound.SC3--> let { x = mouseX KR 60 4000 Linear 0.1->     ; f = roundUp x 100 }-> in audition (out 0 (sinOsc ar f 0 * 0.1))--> let n = line KR 24 108 6 RemoveSynth-> in audition (out 0 (saw AR (midiCPS (roundUp n 1)) * 0.2))
− Help/UGen/Math/scaleNeg.help.lhs
@@ -1,14 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Operator.scaleneg"-> :t scaleNeg--> import Sound.SC3--> let {o = fSinOsc AR 1000 0->     ;l = line AR 1 (-1) 4 RemoveSynth}-> in audition (out 0 (scaleNeg o l))--written out:-> let {o = fSinOsc AR 1000 0->     ;l = line AR 1 (-1) 4 RemoveSynth->     ;c = o <* 0}-> in audition (out 0 (c * (o * l) + (1 - c) * o))
− Help/UGen/Math/softClip.help.lhs
@@ -1,8 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Operator.softclip"-> :t softClip--> import Sound.SC3--> let {e = xLine KR 0.1 10 10 RemoveSynth->     ;o = fSinOsc AR 500 0.0}-> in audition (out 0 (softClip (o * e) * 0.25))
− Help/UGen/Math/sumSqr.help.lhs
@@ -1,13 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Operator.sumsqr"-> :t sumSqr--> import Sound.SC3--> let { a = fSinOsc AR 800 0->     ; b = fSinOsc AR (xLine KR 200 500 5 DoNothing) 0 }-> in audition (out 0 (sumSqr a b * 0.125))--Written out:-> let { a = fSinOsc AR 800 0->     ; b = fSinOsc AR (xLine KR 200 500 5 DoNothing) 0 }-> in audition (out 0 ((a * a + b * b) * 0.125))
− Help/UGen/Math/thresh.help.lhs
@@ -1,8 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Operator.thresh"-> :t thresh--> import Sound.SC3.ID--low-rent gate-> let n = lfNoise0 'a' AR 50 * 0.5-> in audition (out 0 (thresh n 0.45))
− Help/UGen/Noise/brownNoise.help.lhs
@@ -1,12 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "BrownNoise"-> Sound.SC3.UGen.DB.ugenSummary "BrownNoise"--> import Sound.SC3.ID--> let n = brownNoise 'α' AR-> in audition (out 0 (n * 0.1))--> let {n = brownNoise 'α' KR->     ;o = sinOsc AR (linExp n (-1) 1 64 9600) 0 * 0.1}-> in audition (out 0 o)-
− Help/UGen/Noise/choose.help.lhs
@@ -1,8 +0,0 @@-> :t choose--# choose is a composite of iRand and select.--> import Sound.SC3.ID--> let f = uclone 'a' 2 (choose 'a' (mce [440,460 .. 880]))-> in audition (out 0 (sinOsc AR f  0 * 0.1))
− Help/UGen/Noise/clipNoise.help.lhs
@@ -1,8 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "ClipNoise"-> Sound.SC3.UGen.DB.ugenSummary "ClipNoise"--> import Sound.SC3-> import qualified Sound.SC3.Monadic as M--> audition . (out 0) . (* 0.1) =<< M.clipNoise AR-> audition . (out 0) . (* 0.1) =<< M.whiteNoise AR
− Help/UGen/Noise/coinGate.help.lhs
@@ -1,8 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "CoinGate"-> Sound.SC3.UGen.DB.ugenSummary "CoinGate"--> import Sound.SC3.ID--> let {g = coinGate 'a' 0.2 (impulse KR 10 0)->     ;f = tRand 'b' 300.0 400.0 g}-> in audition (out 0 (sinOsc AR f 0 * 0.1))
− Help/UGen/Noise/dust.help.lhs
@@ -1,17 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Dust"-> Sound.SC3.UGen.DB.ugenSummary "Dust"--> import Sound.SC3.ID--> audition (out 0 (dust 'a' AR 200 * 0.25))--> let d = xLine KR 20000 2 10 RemoveSynth-> in audition (out 0 (dust 'a' AR d * 0.15))--Illustrate monadic constructor-> import qualified Sound.SC3.Monadic as M--> audition . (out 0) . (* 0.25) =<< M.dust AR 200--> let d = xLine KR 20000 2 10 RemoveSynth-> in audition . (out 0) . (* 0.15) =<< M.dust AR d
− Help/UGen/Noise/dust2.help.lhs
@@ -1,10 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Dust2"-> Sound.SC3.UGen.DB.ugenSummary "Dust2"--> import Sound.SC3.ID--> let n = dust2 'a' AR 200-> in audition (out 0 (n * 0.5))--> let d = xLine KR 20000 2 10 RemoveSynth-> in audition (out 0 (dust2 'b' AR d * 0.15))
− Help/UGen/Noise/expRand.help.lhs
@@ -1,8 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "ExpRand"-> Sound.SC3.UGen.DB.ugenSummary "ExpRand"--> import Sound.SC3.ID--> let {a = line KR 0.5 0 0.01 RemoveSynth->     ;f = expRand 'a' 100.0 8000.0}-> in audition (out 0 (fSinOsc AR f 0 * a))
− Help/UGen/Noise/grayNoise.help.lhs
@@ -1,7 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "GrayNoise"-> Sound.SC3.UGen.DB.ugenSummary "GrayNoise"--> import Sound.SC3-> import qualified Sound.SC3.Monadic as M--> audition . (out 0) . (* 0.1) =<< M.grayNoise AR
− Help/UGen/Noise/iRand.help.lhs
@@ -1,8 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "IRand"-> Sound.SC3.UGen.DB.ugenSummary "IRand"--> import Sound.SC3.ID--> let {f = iRand 'a' 200 1200->     ;e = line KR 0.2 0 0.1 RemoveSynth}-> in audition (out 0 (fSinOsc AR f 0 * e))
− Help/UGen/Noise/lfClipNoise.help.lhs
@@ -1,15 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "LFClipNoise"-> Sound.SC3.UGen.DB.ugenSummary "LFClipNoise"--> import Sound.SC3.ID-> import qualified Sound.SC3.Monadic as M--> audition . (out 0) . (* 0.05) =<< M.lfClipNoise AR 1000--Modulate frequency-> let f = xLine KR 1000 10000 10 RemoveSynth-> in audition . (out 0) . (* 0.05) =<< M.lfClipNoise AR f--Use as frequency control-> let n = lfClipNoise 'a' KR 4-> in audition (out 0 (sinOsc AR (n * 200 + 600) 0 * 0.1))
− Help/UGen/Noise/lfNoise0.help.lhs
@@ -1,16 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "LFNoise0"-> Sound.SC3.UGen.DB.ugenSummary "LFNoise0"--> import Sound.SC3.ID-> import qualified Sound.SC3.Monadic as M--> audition . (out 0) . (* 0.05) =<< M.lfNoise0 AR 1000--Modulate frequency.-> let {f = xLine KR 1000 10000 10 RemoveSynth->     ;n = lfNoise0 'a' AR f}-> in audition (out 0 (n * 0.05))--Use as frequency control.-> let f = lfNoise0 'a' KR 4-> in audition (out 0 (sinOsc AR (f * 400 + 450) 0 * 0.1))
− Help/UGen/Noise/lfNoise1.help.lhs
@@ -1,18 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "LFNoise1"-> Sound.SC3.UGen.DB.ugenSummary "LFNoise1"--> import Sound.SC3.ID--> audition (out 0 (lfNoise1 'α' AR 1000 * 0.05))--Modulate frequency.--> let {f = xLine KR 1000 10000 10 RemoveSynth->     ;n = lfNoise1 'α' AR f}-> in audition (out 0 (n * 0.05))--Use as frequency control.--> let {n = lfNoise1 'α' KR 4->     ;f = n * 400 + 450}-> in audition (out 0 (sinOsc AR f 0 * 0.1))
− Help/UGen/Noise/lfNoise2.help.lhs
@@ -1,16 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "LFNoise2"-> Sound.SC3.UGen.DB.ugenSummary "LFNoise2"--> import Sound.SC3.ID-> import qualified Sound.SC3.Monadic as M--> audition . (out 0) . (* 0.05) =<< M.lfNoise2 AR 1000--Modulate frequency.-> let {f = xLine KR 1000 10000 10 RemoveSynth->     ;n = lfNoise2 'a' AR f}-> in audition (out 0 (n * 0.05))--Use as frequency control.-> let f = lfNoise2 'a' KR 4-> in audition (out 0 (sinOsc AR (f * 400 + 450) 0 * 0.1))
− Help/UGen/Noise/lfdClipNoise.help.lhs
@@ -1,21 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "LFDClipNoise"-> Sound.SC3.UGen.DB.ugenSummary "LFDClipNoise"--> import Sound.SC3.ID-> import qualified Sound.SC3.Monadic as M--for fast x lfClipNoise frequently seems stuck, lfdClipNoise changes smoothly-> let {x = mouseX KR 0.1 1000 Exponential 0.2->     ;n = lfdClipNoise 'a' AR x}-> in audition (out 0 (sinOsc AR (n * 200 + 500) 0 * 0.05))--> let {x = mouseX KR 0.1 1000 Exponential 0.2->     ;n = lfClipNoise 'a' AR x}-> in audition (out 0 (sinOsc AR (n * 200 + 500) 0 * 0.05))--lfClipNoise quantizes time steps at high freqs, lfdClipNoise does not:-> let f = xLine KR 1000 20000 10 RemoveSynth-> in audition . (out 0) . (* 0.05) =<< M.lfdClipNoise AR f--> let f = xLine KR 1000 20000 10 RemoveSynth-> in audition . (out 0) . (* 0.05) =<< M.lfClipNoise AR f
− Help/UGen/Noise/lfdNoise0.help.lhs
@@ -1,26 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "LFDNoise0"-> Sound.SC3.UGen.DB.ugenSummary "LFDNoise0"--> import Sound.SC3-> import qualified Sound.SC3.Monadic as M--for fast x LFNoise frequently seems stuck, LFDNoise changes smoothly-> let x = mouseX KR 0.1 1000 Exponential 0.2-> in audition . (out 0) . (* 0.1) =<< M.lfdNoise0 AR x--> let x = mouseX KR 0.1 1000 Exponential 0.2-> in audition . (out 0) . (* 0.1) =<< M.lfNoise0 AR x--silent for 2 secs before going up in freq-> let f = xLine KR 0.5 10000 3 RemoveSynth-> in audition . (out 0) . (* 0.1) =<< M.lfdNoise0 AR f--> let f = xLine KR 0.5 10000 3 RemoveSynth-> in audition . (out 0) . (* 0.1) =<< M.lfNoise0 AR f--LFNoise quantizes time steps at high freqs, LFDNoise does not:-> let f = xLine KR 1000 20000 10 RemoveSynth-> in audition . (out 0) . (* 0.1) =<< M.lfdNoise0 AR f--> let f = xLine KR 1000 20000 10 RemoveSynth-> in audition . (out 0) . (* 0.1) =<< M.lfNoise0 AR f
− Help/UGen/Noise/lfdNoise1.help.lhs
@@ -1,4 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "LFDNoise1"-> Sound.SC3.UGen.DB.ugenSummary "LFDNoise1"--See lfdNoise0
− Help/UGen/Noise/lfdNoise3.help.lhs
@@ -1,4 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "LFDNoise3"-> Sound.SC3.UGen.DB.ugenSummary "LFDNoise3"--See lfdNoise0
− Help/UGen/Noise/linRand.help.lhs
@@ -1,8 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "LinRand"-> Sound.SC3.UGen.DB.ugenSummary "LinRand"--> import Sound.SC3.ID--> let {f = linRand 'a' 200.0 10000.0 (mce [-1, 1])->     ;e = line KR 0.4 0 0.01 RemoveSynth}-> in audition (out 0 (fSinOsc AR f 0 * e))
− Help/UGen/Noise/nRand.help.lhs
@@ -1,8 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "NRand"-> Sound.SC3.UGen.DB.ugenSummary "NRand"--> import Sound.SC3.ID--> let {n = nRand 'a' 1200.0 4000.0 (mce [2,5])->     ;e = line KR 0.2 0 0.1 RemoveSynth}-> in audition (out 0 (fSinOsc AR n 0 * e))
− Help/UGen/Noise/pinkNoise.help.lhs
@@ -1,8 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "PinkNoise"-> Sound.SC3.UGen.DB.ugenSummary "PinkNoise"--> import Sound.SC3.Monadic--> audition . (out 0) . (* 0.05) =<< pinkNoise AR-> audition . (out 0) . (* 0.05) =<< whiteNoise AR-> audition . (out 0) . (* 0.05) =<< brownNoise AR
− Help/UGen/Noise/rand.help.lhs
@@ -1,10 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Rand"-> Sound.SC3.UGen.DB.ugenSummary "Rand"--> import Sound.SC3.ID--> let {f = rand 'a' 200 1200->     ;l = rand 'b' (-1) 1->     ;e = line KR 0.2 0 0.1 RemoveSynth->     ;o = fSinOsc AR f 0}-> in audition (out 0 (pan2 (o * e) l 1))
− Help/UGen/Noise/randID.help.lhs
@@ -1,2 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "RandID"-> Sound.SC3.UGen.DB.ugenSummary "RandID"
− Help/UGen/Noise/randSeed.help.lhs
@@ -1,22 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "RandSeed"-> Sound.SC3.UGen.DB.ugenSummary "RandSeed"--> import Sound.SC3.ID--start a noise patch-> let {n = uclone 'a' 2 (whiteNoise 'a' AR * 0.05 + dust2 'a' AR 70)->     ;f = lfNoise1 'a' KR 3 * 5500 + 6000->     ;r = resonz (n * 5) f 0.5 + n * 0.5}-> in audition (out 0 r)--reset the seed at a variable rate-> let {s = control KR "seed" 1956->     ;r = randSeed KR (impulse KR (mouseX KR 0.1 100 Linear 0.2) 0) s}-> in audition r--always the same (for a given seed)...-> let {sd = 1957->     ;n = tIRand 'a' 4 12 (dust 'a' KR 1)->     ;f = n * 150 + (mce [0,1])->     ;r = randSeed IR 1 sd}-> in audition (out 0 (mrg2 (sinOsc AR f 0 * 0.1) r))
− Help/UGen/Noise/tExpRand.help.lhs
@@ -1,7 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "TExpRand"-> Sound.SC3.UGen.DB.ugenSummary "TExpRand"--> import Sound.SC3.Monad--> do { f <- tExpRand 300.0 3000.0 =<< dust KR 10->    ; audition (out 0 (sinOsc AR f 0 * 0.1)) }
− Help/UGen/Noise/tIRand.help.lhs
@@ -1,13 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "TIRand"-> Sound.SC3.UGen.DB.ugenSummary "TIRand"--> import Sound.SC3-> import qualified Sound.SC3.Monadic as M--> do {l <- M.tIRand (-1) 1 =<< M.dust KR 10->    ;n <- M.pinkNoise AR->    ;audition (out 0 (pan2 (n * 0.1) l 1))}--> do {n <- M.tIRand 4 12 =<< M.dust KR 10->    ;let f = n * 150 + (mce [0,1])->     in audition (out 0 (sinOsc AR f 0 * 0.1))}
− Help/UGen/Noise/tRand.help.lhs
@@ -1,8 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "TRand"-> Sound.SC3.UGen.DB.ugenSummary "TRand"--> import Sound.SC3.ID--> let {t = dust 'α' KR (mce2 5 12)->     ;f = tRand 'β' (mce2 200 1600) (mce2 500 3000) t}-> in audition (out 0 (sinOsc AR f 0 * 0.2))
− Help/UGen/Noise/whiteNoise.help.lhs
@@ -1,35 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "WhiteNoise"-> Sound.SC3.UGen.DB.ugenSummary "WhiteNoise"--> import Sound.SC3.ID--> audition (out 0 (whiteNoise 'a' AR * 0.05))--Random filtered noise bursts.-> let {n = whiteNoise 'a' AR->     ;t = dust 'a' AR (mce [3, 7])->     ;f = tExpRand 'a' 20 1800 t->     ;bw = tExpRand 'a' 0.001 1 t->     ;e = decay2 t 0.01 0.2->     ;r = resonz (n * e) f bw}-> in audition (out 0 r)--> import qualified Sound.SC3.Monadic as M--Monadic form of above graph.-> do {n <- M.whiteNoise AR->    ;t <- M.dust AR (mce [3, 7])->    ;f <- M.tExpRand 20 1800 t->    ;bw <- M.tExpRand 0.001 1 t->    ;let {e = decay2 t 0.01 0.2->         ;r = resonz (n * e) f bw}->      in audition (out 0 r)}--The same graph again, without using do notation.-> M.whiteNoise AR >>= \n ->-> M.dust AR (mce [3, 7]) >>= \t ->-> M.tExpRand 20 1800 t >>= \f ->-> M.tExpRand 0.001 1 t >>= \bw ->-> let {e = decay2 t 0.01 0.2->     ;r = resonz (n * e) f bw}-> in audition (out 0 r)
− Help/UGen/Oscillator/blip.help.lhs
@@ -1,22 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Blip"-> Sound.SC3.UGen.DB.ugenSummary "Blip"--> import Sound.SC3 {- hsc3 -}--> audition (out 0 (blip AR 440 200 * 0.1))--Modulate frequency--> let f = xLine KR 20000 200 6 RemoveSynth-> in audition (out 0 (blip AR f 100 * 0.1))--Modulate number of harmonics.--> let nh = line KR 1 100 20 RemoveSynth-> in audition (out 0 (blip AR 200 nh * 0.2))--Self-modulation at control rate.--> let {fr = blip KR 0.25 3 * 300 + 500->     ;nh = blip KR 0.15 2 * 20 + 21}-> in audition (out 0 (blip AR fr nh * 0.2))
− Help/UGen/Oscillator/cOsc.help.lhs
@@ -1,23 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "COsc"-> Sound.SC3.UGen.DB.ugenSummary "COsc"--> import Sound.SC3--Allocate and fill buffer.--> let {f = [Normalise,Wavetable,Clear]->     ;d = [1,1/2,1/3,1/4,1/5,1/6,1/7,1/8,1/9,1/10]}-> in withSC3 ( do {_ <- async (b_alloc 10 512 1)->                 ;async (b_gen_sine1 10 f d)})--Fixed beat frequency--> audition (out 0 (cOsc AR 10 200 0.7 * 0.1))--Modulate beat frequency with mouseX--> audition (out 0 (cOsc AR 10 200 (mouseX KR 0 4 Linear 0.2) * 0.1))--Compare with plain osc--> audition (out 0 (osc AR 10 200 0.0 * 0.1))
− Help/UGen/Oscillator/dc.help.lhs
@@ -1,24 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "DC"-> Sound.SC3.UGen.DB.ugenSummary "DC"--> import Sound.SC3--nothing--> audition (out 0 0)-> withSC3 (send (n_trace [-1]))--zero--> audition (out 0 (dc AR 0))--DC offset; will click on start and finish--> audition (out 0 (dc AR 0.5))-> audition (out 0 (0.5 + sinOsc AR 440 0 * 0.1))-> audition (out 0 (dc AR 0.5 + sinOsc AR 440 0 * 0.1))--Transient before LeakDC adapts and suppresses the offset?--> audition (out 0 (dc AR 1))-> audition (out 0 (leakDC (dc AR 1) 0.995))
− Help/UGen/Oscillator/dynKlang.help.lhs
@@ -1,22 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "DynKlang"-> Sound.SC3.UGen.DB.ugenSummary "DynKlang"--> import Sound.SC3.ID {- hsc3 -}--fixed--> let s = klangSpec [800,1000,1200] [0.3,0.3,0.3] [pi,pi,pi]-> in audition (out 0 (dynKlang AR 1 0 s * 0.4))--fixed: randomised--> let {f = map (\z -> rand z 600 1000) ['a'..'l']->     ;s = klangSpec f (replicate 12 1) (replicate 12 0)}-> in audition (out 0 (dynKlang AR 1 0 s * 0.05))--dynamic: frequency modulation--> let {f = mce3 800 1000 1200 + sinOsc KR (mce3 2 3 4.2) 0 * mce3 13 24 12->     ;a = mce3 0.3 0.3 0.3->     ;p = mce3 pi pi pi}-> in audition (out 0 (dynKlang AR 1 0 (klangSpec_mce f a p) * 0.1))
− Help/UGen/Oscillator/fSinOsc.help.lhs
@@ -1,42 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "FSinOsc"-> Sound.SC3.UGen.DB.ugenSummary "FSinOsc"--# SC2 did not have the initial phase argument.--> import Sound.SC3--> audition (out 0 (fSinOsc AR (mce2 440 550) 0 * 0.05))--Modulate frequency--> audition (out 0 (fSinOsc AR (xLine KR 200 4000 1 RemoveSynth) 0 * 0.1))--Loses amplitude towards the end--> let f = fSinOsc AR (xLine KR 4 401 8 RemoveSynth)-> in audition (out 0 (fSinOsc AR (f 0 * 200 + 800) 0 * 0.1))--sin grain with sine envelope (see also 'sine_grain_ugen_graph')--> let sine = let {b = control IR "out" 0->                ;f = control IR "freq" 440->                ;d = control IR "dur" 0.2->                ;a = control IR "amp" 0.1->                ;p = control IR "pan" 0->                ;o = fSinOsc AR f 0->                ;s = envSine d a->                ;e = envGen AR 1 1 0 1 RemoveSynth s->                ;u = offsetOut b (pan2 o p e)}->            in synthdef "sine" u--> import Sound.SC3.Lang.Pattern {- hsc3-lang -}--granular synthesis--> audition (pbind [(K_instr,psynth sine)->                 ,(K_midinote,fmap roundE (pbrown 'α' 72 84 1 inf))->                 ,(K_detune,pwhite 'β' 0 10 inf)->                 ,(K_dur,pbrown 'γ' 0.005 0.15 0.05 inf)->                 ,(K_legato,pbrown 'δ' 1 2 0.1 inf)->                 ,(K_amp,pbrown 'ε' 0.05 0.25 0.05 inf)->                 ,(K_param "pan",pbrown 'ζ' (-1) 1 0.2 inf)])
− Help/UGen/Oscillator/formant.help.lhs
@@ -1,20 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Formant"-> Sound.SC3.UGen.DB.ugenSummary "Formant"--> import Sound.SC3--Modulate fundamental frequency, formant frequency stays constant.--> let f = xLine KR 400 1000 8 RemoveSynth-> in audition (out 0 (formant AR f 2000 800 * 0.125))--Modulate formant frequency, fundamental frequency stays constant.--> let {f = mce [200, 300, 400, 500]->     ;ff = xLine KR 400 4000 8 RemoveSynth}-> in audition (out 0 (formant AR f ff 200 * 0.125))--Modulate width frequency, other frequencies stay constant.--> let bw = xLine KR 800 8000 8 RemoveSynth-> in audition (out 0 (formant AR 400 2000 bw * 0.1))
− Help/UGen/Oscillator/gendy1.help.lhs
@@ -1,96 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Gendy1"-> Sound.SC3.UGen.DB.ugenSummary "Gendy1"--> import Sound.SC3.ID--SC3 default parameters-> let g = gendy1 AR 1 1 1 1 440 660 0.5 0.5 12 12-> in audition (out 0 (pan2 g 0 0.15))--Wandering bass-> let g = gendy1 AR 1 1 1.0 1.0 30 100 0.3 0.05 5 5-> in audition (out 0 (pan2 g 0 0.15))--Play me-> let {x = mouseX KR 100 1000 Exponential 0.1->     ;g = gendy1 AR 1 1 1.0 1.0 30 100 0.3 0.05 5 5}-> in audition (out 0 (pan2 (rlpf g 500 0.3 * 0.2) 0 0.25))--Scream!-> let {x = mouseX KR 220 440 Exponential 0.1->     ;y = mouseY KR 0.0 1.0 Linear 0.1}-> in audition (out 0 (pan2 (gendy1 AR 2 3 1 1 x (8 * x) y y 7 7) 0.0 0.3))--1 CP = random noise-> let g = gendy1 AR 1 1 1 1 440 660 0.5 0.5 1 1-> in audition (out 0 (pan2 g 0 0.15))--2 CPs = an oscillator-> let g = gendy1 AR 1 1 1 1 440 660 0.5 0.5 2 2-> in audition (out 0 (pan2 g 0 0.15))--Used as an LFO-> let {ad = sinOsc KR 0.10 0 * 0.49 + 0.51->     ;dd = sinOsc KR 0.13 0 * 0.49 + 0.51->     ;as = sinOsc KR 0.17 0 * 0.49 + 0.51->     ;ds = sinOsc KR 0.19 0 * 0.49 + 0.51->     ;g = gendy1 KR 2 4 ad dd 3.4 3.5 as ds 10 10}-> in audition (out 0 (pan2 (sinOsc AR (g * 50 + 350) 0) 0.0 0.3))--Wasp-> let ad = sinOsc KR 0.1 0 * 0.1 + 0.9-> in audition (out 0 (pan2 (gendy1 AR 0 0 ad 1.0 50 1000 1 0.005 12 12) 0.0 0.2))--Modulate distributions. Change of pitch as distributions change-the duration structure and spectrum-> let {x = mouseX KR 0 7 Linear 0.1->     ;y = mouseY KR 0 7 Linear 0.1->     ;g = gendy1 AR x y 1 1 440 660 0.5 0.5 12 12}-> in audition (out 0 (pan2 g 0 0.2))--Modulate number of CPs.-> let {x = mouseX KR 1 13 Linear 0.1->     ;g = gendy1 AR 1 1 1 1 440 660 0.5 0.5 12 x}-> in audition (out 0 (pan2 g 0 0.2))--Self modulation.-> let {x = mouseX KR 1   13 Linear 0.1->     ;y = mouseY KR 0.1 10 Linear 0.1->     ;g0 = gendy1 AR 5 4 0.3 0.7 0.1 y 1.0 1.0 5 5->     ;g1 = gendy1 AR 1 1 1 1 440 (g0 * 500 + 600) 0.5 0.5 12 x}-> in audition (out 0 (pan2 g1 0 0.2))--Use SINUS to track any oscillator and take CP positions from it use-adParam and ddParam as the inputs to sample.-> let {p = lfPulse KR 100 0 0.4->     ;s = sinOsc KR 30 0 * 0.5->     ;g = gendy1 AR 6 6 p s 440 660 0.5 0.5 12 12}-> in audition (out 0 (pan2 g 0 0.2))--Near the corners are interesting.-> let {x = mouseX KR 0 200 Linear 0.1->     ;y = mouseY KR 0 200 Linear 0.1->     ;p = lfPulse KR x 0 0.4->     ;s = sinOsc KR y 0 * 0.5->     ;g = gendy1 AR 6 6 p s 440 660 0.5 0.5 12 12}-> in audition (out 0 (pan2 g 0 0.2))--Texture-> let node e = let {f = rand e 130 160.3->                  ;r0 = rand e 0 6->                  ;r1 = rand (Data.Char.toUpper e) 0 6->                  ;l = rand e (-1) 1->                  ;ad = sinOsc KR 0.10 0 * 0.49 + 0.51->                  ;dd = sinOsc KR 0.13 0 * 0.49 + 0.51->                  ;as = sinOsc KR 0.17 0 * 0.49 + 0.51->                  ;ds = sinOsc KR 0.19 0 * 0.49 + 0.51->                  ;g = gendy1 AR r0 r1 ad dd f f as ds 12 12->                  ;o = sinOsc AR (g * 200 + 400) 0}->              in pan2 o l 0.1-> in audition (out 0 (mix (mce (map node ['a'..'i']))))--Try durscale 10.0 and 0.0 too.-> let {x = mouseX KR 10 700 Linear 0.1->     ;y = mouseY KR 50 1000 Linear 0.1->     ;g = gendy1 AR 2 3 1 1 1 x 0.5 0.1 10 10}-> in audition (out 0 (pan2 (combN (resonz g y 0.1) 0.1 0.1 5) 0.0 0.6))
− Help/UGen/Oscillator/impulse.help.lhs
@@ -1,19 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Impulse"-> Sound.SC3.UGen.DB.ugenSummary "Impulse"--# SC2 had no phase input.--> import Sound.SC3--> audition (out 0 (impulse AR 800 0 * 0.1))--> let f = xLine KR 800 10 5 RemoveSynth-> in audition (out 0 (impulse AR f 0.0 * 0.1))--> let {f = mouseY KR 4 8 Linear 0.1->     ;x = mouseX KR 0 1 Linear 0.1}-> in audition (out 0 (impulse AR f (mce [0,x]) * 0.1))--An impulse with frequency 0 returns a single impulse--> audition (out 0 (decay (impulse AR 0 0) 1 * brownNoise 'a' AR * 0.1))
− Help/UGen/Oscillator/klang.help.lhs
@@ -1,28 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Klang"-> Sound.SC3.UGen.DB.ugenSummary "Klang"--# SC2 had mul/add inputs.--> import Sound.SC3.ID--> let {f = [440,550..1100]->     ;a = take 7 (cycle [0.05, 0.02])->     ;p = replicate 7 0}-> in audition (out 0 (klang AR 1 0 (klangSpec f a p)))--play({Klang.ar(`[[800,1000,1200],[0.3,0.3,0.3],[pi,pi,pi]],1,0)*0.4})--> let s = klangSpec [800,1000,1200] [0.3,0.3,0.3] [pi,pi,pi]-> in audition (out 0 (klang AR 1 0 s * 0.4))--play({Klang.ar(`[[800,1000,1200],nil,nil],1,0)*0.25})--> let s = klangSpec [800,1000,1200] [1,1,1] [0,0,0]-> in audition (out 0 (klang AR 1 0 s * 0.25))--play({Klang.ar(`[Array.rand(12,600.0,1000.0),nil,nil],1,0)*0.05})--> let {f = map (\z -> rand z 600 1000) ['a'..'l']->     ;s = klangSpec f (replicate 12 1) (replicate 12 0)}-> in audition (out 0 (klang AR 1 0 s * 0.05))-
− Help/UGen/Oscillator/lfCub.help.lhs
@@ -1,27 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "LFCub"-> Sound.SC3.UGen.DB.ugenSummary "LFCub"--> import Sound.SC3--> audition (out 0 (lfCub AR (lfCub KR (lfCub KR 0.2 0 * 8 + 10) 0 * 400 + 800) 0 * 0.1))-> audition (out 0 (lfCub AR (lfCub KR 0.2 0 * 400 + 800) 0 * 0.1))-> audition (out 0 (lfCub AR 800 0 * 0.1))-> audition (out 0 (lfCub AR (xLine KR 100 8000 30 DoNothing) 0 * 0.1))--Compare w/ lfPar-> audition (out 0 (lfPar AR (lfPar KR (lfPar KR 0.2 0 * 8 + 10) 0 * 400 + 800) 0 * 0.1))-> audition (out 0 (lfPar AR (lfPar KR 0.2 0 * 400 + 800) 0 * 0.1))-> audition (out 0 (lfPar AR 800 0 * 0.1))-> audition (out 0 (lfPar AR (xLine KR 100 8000 30 DoNothing) 0 * 0.1))--Compare w/ sinOsc-> audition (out 0 (sinOsc AR (sinOsc KR (sinOsc KR 0.2 0 * 8 + 10) 0 * 400 + 800) 0 * 0.1))-> audition (out 0 (sinOsc AR (sinOsc KR 0.2 0 * 400 + 800) 0 * 0.1))-> audition (out 0 (sinOsc AR 800 0 * 0.1))-> audition (out 0 (sinOsc AR (xLine KR 100 8000 30 DoNothing) 0 * 0.1))--Compare w/ lfTri-> audition (out 0 (lfTri AR (lfTri KR (lfTri KR 0.2 0 * 8 + 10) 0 * 400 + 800) 0 * 0.1))-> audition (out 0 (lfTri AR (lfTri KR 0.2 0 * 400 + 800) 0 * 0.1))-> audition (out 0 (lfTri AR 800 0 * 0.1))-> audition (out 0 (lfTri AR (xLine KR 100 8000 30 DoNothing) 0 * 0.1))
− Help/UGen/Oscillator/lfGauss.help.lhs
@@ -1,82 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "LFGauss"-> Sound.SC3.UGen.DB.ugenSummary "LFGauss"--> import Sound.SC3--modulating duration-> let {d = xLine KR 0.1 0.001 10 DoNothing->     ;g = lfGauss AR d 0.03 0 Loop DoNothing}-> in audition (out 0 (g * 0.2))--modulating width, freq 60 Hz-> let {w = xLine KR 0.1 0.001 10 DoNothing->     ;g = lfGauss AR (1/60) w 0 Loop DoNothing}-> in audition (out 0 (g * 0.2))--modulating both: x position is frequency, y is width factor.-note the artefacts due to alisasing at high frequencies-> let {d = mouseX KR (1/8000) 0.1 Exponential 0.2->     ;w = mouseX KR 0.001 0.1 Exponential 0.2->     ;g = lfGauss AR d w 0 Loop DoNothing}-> in audition (out 0 (g * 0.1))--LFGauss as amplitude modulator-> let {d = mouseX KR 1 0.001 Exponential 0.2->     ;g = lfGauss AR d 0.1 0 Loop DoNothing->     ;o = sinOsc AR 1000 0}-> in audition (out 0 (g * o * 0.1))--modulate iphase-> let {ph = mouseX KR (-1) 1 Linear 0.2->     ;g = lfGauss AR 0.001 0.2 (mce2 0 ph) Loop DoNothing}-> in audition (out 0 (mix g * 0.2))--for very small width we are "approaching" a dirac function-> let {w = sampleDur * mouseX KR 10 3000 Exponential 0.2->     ;g = lfGauss AR 0.01 w 0 Loop DoNothing}-> in audition (out 0 (g * 0.2))--dur and width can be modulated at audio rate-> let {x = mouseX KR 2 1000 Exponential 0.2->     ;d = range 0.0006 0.01 (sinOsc AR x 0 * mce2 1 1.1)->     ;w = range 0.01 0.3 (sinOsc AR (0.5 * (mce2 1 1.1)) 0)->     ;g = lfGauss AR d w 0 Loop DoNothing}-> in audition (out 0 (g * 0.2))--several frequencies and widths combined-> let {x = mouseX KR 1 0.07 Exponential 0.2->     ;y = mouseY KR 1 3 Linear 0.2->     ;g = lfGauss AR x (y ** mce [-1,-2 .. -6]) 0 Loop DoNothing->     ;o = sinOsc AR (200 * (1.3 ** mce [0..5])) 0}-> in audition (out 0 (mix (g * o) * 0.1))--> withSC3 (send (n_trace [-1]))--gabor grain (see also 'gabor_grain_ugen_graph')-> let gabor = let {b = control IR "out" 0->                 ;f = control IR "freq" 440->                 ;s = control IR "sustain" 1->                 ;p = control IR "pan" 1->                 ;a = control IR "amp" 0.1->                 ;w = control IR "width" 0.25->                 ;e = lfGauss AR s w 0 NoLoop RemoveSynth->                 ;o = fSinOsc AR f (pi / 2) * e->                 ;u = offsetOut b (pan2 o p a)}->             in synthdef "gabor" u--> import Sound.SC3.Lang.Pattern {- hsc3-lang -}--granular synthesis, modulating duration, width and pan-> audition (pbind [(K_instr,psynth gabor)->                 ,(K_freq,1000)->                 ,(K_legato,2)->                 ,(K_dur,pbrown 'α' 0.005 0.025 0.001 inf)->                 ,(K_param "width",pbrown 'β' 0.05 0.25 0.005 inf)->                 ,(K_param "pan",pbrown 'γ' (-1) 1 0.05 inf)])--granular synthesis, modulating width only-> audition (pbind [(K_instr,psynth gabor)->                 ,(K_freq,1000)->                 ,(K_dur,0.01)->                 ,(K_param "width",pgeom 0.25 0.995 1250)->                 ,(K_legato,2)])
− Help/UGen/Oscillator/lfPar.help.lhs
@@ -1,4 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "LFPar"-> Sound.SC3.UGen.DB.ugenSummary "LFPar"--See lfCub
− Help/UGen/Oscillator/lfPulse.help.lhs
@@ -1,26 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "LFPulse"-> Sound.SC3.UGen.DB.ugenSummary "LFPulse"--# SC2 had no initial phase argument.--> import Sound.SC3--> let f = lfPulse KR 3 0 0.3 * 200 + 200-> in audition (out 0 (lfPulse AR f 0 0.2 * 0.1))--> let x = mouseX KR 0 1 Linear 0.2-> in audition (out 0 (lfPulse AR 220 0 x * 0.1))--square wave as sum of sines.-for odd partials n, amplitude is (1 / n), for even partials amplitude is 0.-phase is always 0.--> let {mk_freq f0 n = f0 * fromInteger n->     ;mk_amp n = if even n then 0 else 1 / fromInteger n->     ;mk_param f0 n = let m = [1,3 .. n] in zip (map (mk_freq f0) m) (map mk_amp m)->     ;x = midiCPS (mouseX KR 20 72 Linear 0.2)->     ;y = mouseY KR 0.01 0.1 Exponential 0.2->     ;e = xLine KR 0.01 1 20 DoNothing->     ;o1 = sum (map (\(fr,am) -> sinOsc AR fr 0 * am) (mk_param x 50)) * (1 - e)->     ;o2 = lfPulse AR x 0 0.5 * e}-> in audition (out 0 (mce2 o1 o2 * y))
− Help/UGen/Oscillator/lfSaw.help.lhs
@@ -1,32 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "LFSaw"-> Sound.SC3.UGen.DB.ugenSummary "LFSaw"--# SC2 did not have the initial phase argument.--> import Sound.SC3--> audition (out 0 (lfSaw AR 500 1 * 0.1))--Used as both Oscillator and LFO.--> audition (out 0 (lfSaw AR (lfSaw KR 4 0 * 400 + 400) 0 * 0.1))--Output range is bi-polar.--> let {f = mce [linLin (lfSaw KR 0.5 0) (-1) 1 200 1600, 200, 1600]->     ;a = mce [0.1,0.05,0.05]}-> in audition (out 0 (mix (sinOsc AR f 0 * a)))--saw-tooth wave as sum of sines.-for all partials n, amplitude is (1 / n).-phase is always 0.--> let {mk_freq f0 n = f0 * fromInteger n->     ;mk_amp n = 1 / fromInteger n->     ;mk_param f0 n = let m = [1,2 .. n] in zip (map (mk_freq f0) m) (map mk_amp m)->     ;x = midiCPS (mouseX KR 20 72 Linear 0.2)->     ;y = mouseY KR 0.01 0.1 Exponential 0.2->     ;e = xLine KR 0.01 1 20 DoNothing->     ;o1 = sum (map (\(fr,am) -> sinOsc AR fr 0 * am) (mk_param x 25)) * (1 - e)->     ;o2 = lfSaw AR x 0 * e}-> in audition (out 0 (mce2 o1 o2 * y))
− Help/UGen/Oscillator/lfTri.help.lhs
@@ -1,32 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "LFTri"-> Sound.SC3.UGen.DB.ugenSummary "LFTri"--> import Sound.SC3--> audition (out 0 (lfTri AR 500 1 * 0.1))--Used as both Oscillator and LFO.--> audition (out 0 (lfTri AR (lfTri KR 4 0 * 400 + 400) 0 * 0.1))--Multiple phases--> let f = lfTri KR 0.4 (mce [0..3]) * 200 + 400-> in audition (out 0 (mix (lfTri AR f 0 * 0.1)))--triangle wave as sum of sines.-for partial n, amplitude is (1 / square n) and phase is pi at every other odd partial--> import Sound.SC3.UGen.Dot--> let {mk_freq f0 n = f0 * fromInteger n->     ;mk_amp n = if even n then 0 else 1 / fromInteger (n * n)->     ;mk_ph n = if n + 1 `mod` 4 == 0 then pi else 0->     ;mk_param f0 n =->      let m = [1,3 .. n]->      in zip3 (map (mk_freq f0) m) (map mk_ph m) (map mk_amp m)->     ;x = midiCPS (mouseX KR 20 72 Linear 0.2)->     ;e = xLine KR 0.01 1 20 DoNothing->     ;o1 = sum (map (\(fr,ph,am) -> sinOsc AR fr ph * am) (mk_param x 25)) * (1 - e)->     ;o2 = lfTri AR x 0 * e}-> in audition (out 0 (mce2 o1 o2 * 0.1))
− Help/UGen/Oscillator/osc1.help.lhs
@@ -1,9 +0,0 @@-> import Sound.SC3--> withSC3 (let {z = [Normalise,Wavetable,Clear]->              ;a = [[13,8,55,34,5,21,3,1,2],[55,34,1,3,2,13,5,8,21]]->              ;f (b,l) = do {_ <- async (b_alloc b 512 1)->                            ;send (b_gen_sine1 b z (map recip l))}}->          in mapM_ f (zip [10,11] a))--> audition (out 0 (lfSaw AR (mce2 110 164) 0 * 0.1 * osc1 AR (mce2 10 11) 4 RemoveSynth))
− Help/UGen/Oscillator/oscN.help.lhs
@@ -1,4 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "OscN"-> Sound.SC3.UGen.DB.ugenSummary "OscN"--See osc
− Help/UGen/Oscillator/pmOsc.help.lhs
@@ -1,22 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "PMOsc"-> :t pmOsc--# pmOsc is a composite of sinOsc, ie. sinOsc r cf (sinOsc r mf mp * pm)--> import Sound.SC3.ID--Random parameters, linear modulation index motion over n seconds-> let pmi n = let {cf = rand 'α' 0 2000->                 ;mf = rand 'β' 0 800->                 ;pme = rand 'γ' 0 12->                 ;l = rand 'δ' (-1) 1->                 ;pm = line KR 0 pme n DoNothing}-> in linPan2 (pmOsc AR cf mf pm 0) l 0.05--> audition (out 0 (pmi 2))--PM textures-> import qualified Sound.SC3.Lang.Control.OverlapTexture as L-> L.overlapTextureU (0,1,8,maxBound) (pmi 1)-> L.overlapTextureU (1,2,7,maxBound) (pmi 2)-> L.overlapTextureU (6,6,6,maxBound) (pmi 12)
− Help/UGen/Oscillator/pulse.help.lhs
@@ -1,20 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Pulse"-> Sound.SC3.UGen.DB.ugenSummary "Pulse"--> import Sound.SC3--Modulate frequency--> let f = xLine KR 40 4000 6 RemoveSynth-> in audition (out 0 (pulse AR f 0.1 * 0.1))--Modulate pulse width--> let w = line KR 0.01 0.99 8 RemoveSynth-> in audition (out 0 (pulse AR 200 w * 0.1))--Two band limited square waves through a resonant low pass filter--> let {p = pulse AR (mce2 100 250) 0.5 * 0.1->     ;f = xLine KR 8000 400 5 DoNothing}-> in audition (out 0 (rlpf p f 0.05))
− Help/UGen/Oscillator/saw.help.lhs
@@ -1,10 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Saw"-> Sound.SC3.UGen.DB.ugenSummary "Saw"--> import Sound.SC3--> audition (out 0 (saw AR (xLine KR 40 4000 6 RemoveSynth) * 0.1))--Two band limited sawtooth waves thru a resonant low pass filter-> let f = xLine KR 8000 400 5 DoNothing-> in audition (out 0 (rlpf (saw AR (mce2 100 250) * 0.1) f 0.05))
− Help/UGen/Oscillator/silent.help.lhs
@@ -1,6 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Silent"-> Sound.SC3.UGen.DB.ugenSummary "Silent"--> import Sound.SC3--> audition (out 0 (silent 1))
− Help/UGen/Oscillator/sinOsc.help.lhs
@@ -1,47 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "SinOsc"-> Sound.SC3.UGen.DB.ugenSummary "SinOsc"--> import Sound.SC3--Fixed frequency--> audition (out 0 (sinOsc AR 440 0 * 0.25))--Modulate freq--> audition (out 0 (sinOsc AR (xLine KR 2000 200 9 RemoveSynth) 0 * 0.5))--Modulate freq--> let f = sinOsc AR (xLine KR 1 1000 9 RemoveSynth) 0 * 200 + 800-> in audition (out 0 (sinOsc AR f 0 * 0.1))--Modulate phase--> let p = sinOsc AR (xLine KR 20 8000 10 RemoveSynth) 0 * 2 * pi-> in audition (out 0 (sinOsc AR 800 p * 0.1))--Simple bell-like tone.--> let {f = mce [0.5,1,1.19,1.56,2,2.51,2.66,3.01,4.1]->     ;a = mce [0.25,1,0.8,0.5,0.9,0.4,0.3,0.6,0.1]->     ;o = sinOsc AR (500 * f) 0 * a->     ;e = envGen KR 1 0.1 0 1 RemoveSynth (envPerc 0.01 10)}-> in audition (out 0 (mix o * e))--"When two pure tones of slightly different frequency are superposed,-our ears perceive audible beats at a rate given by the difference of-the two frequencies."--> let {f0 = 220;f1 = 221.25;d = abs (f1 - f0)}-> in audition (out 0 (sinOsc AR (mce2 f0 f1) 0 * 0.1 + impulse AR d 0 * 0.25))--"When two tones are sounded together, a tone of lower frequency is-frequently heard. Such a tone is called a combination tone.  The most-commonly heard combination tone occurs at a frequency f2 - f1."--> let {f1 = 300->     ;f2 = 300 * (3/2)->     ;f = mce2 (mce2 f1 f2) (abs (f2 - f1))->     ;a = mce2 0.1 (max (sinOsc KR 0.05 0 * 0.1) 0)}-> in audition (out 0 (sinOsc AR f 0 * a))
− Help/UGen/Oscillator/sinOscFB.help.lhs
@@ -1,28 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "SinOscFB"-> Sound.SC3.UGen.DB.ugenSummary "SinOscFB"--> import Sound.SC3--{SinOscFB.ar([400,301],MouseX.kr(0,4))*0.1}.play--> let {x = mouseX KR 0 4 Linear 0.2->     ;o = sinOscFB AR (mce2 400 301) x * 0.1}-> in audition (out 0 o)--{y=MouseY.kr(10,1000,'exponential')-;x=MouseX.kr(0.5pi,pi)-;SinOscFB.ar(y,x)*0.1}.play--> let {y = mouseY KR 10 1000 Exponential 0.2->     ;x = mouseX KR (pi/2) pi Linear 0.2->     ;o = sinOscFB AR y x * 0.1}-> in audition (out 0 o)--{y=MouseY.kr(1,1000,'exponential')-;x=MouseX.kr(0.5pi,pi)-;SinOscFB.ar(100*SinOscFB.ar(y)+200,x)*0.1}.play--> let {y = mouseY KR 1 1000 Exponential 0.2->     ;x = mouseX KR (pi/2) pi Linear 0.2->     ;o = sinOscFB AR (100 * sinOscFB AR y 0 + 200) x * 0.1}-> in audition (out 0 o)
− Help/UGen/Oscillator/syncSaw.help.lhs
@@ -1,12 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "SyncSaw"-> Sound.SC3.UGen.DB.ugenSummary "SyncSaw"--> import Sound.SC3--> let f = line KR 100 800 12 RemoveSynth-> in audition (out 0 (syncSaw AR 100 f * 0.1))--Mouse control-> let {sy_f = mouseY KR 80 220 Exponential 0.2->     ;sw_f = sy_f * mouseX KR 1 3 Linear 0.2}-> in audition (out 0 (syncSaw AR sy_f sw_f * 0.1))
− Help/UGen/Oscillator/tChoose.help.lhs
@@ -1,15 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "TChoose"-> :t tChoose--# tChoose is a composite of tIRand and select.--> import Sound.SC3--> let {x = mouseX KR 1 1000 Exponential 0.1->     ;t = dust 'a' AR x->     ;f = midiCPS (tIRand 'b' 48 60 t)->     ;o = let a = mce [sinOsc AR f 0->                      ,saw AR (f * 2)->                      ,pulse AR (f * 0.5) 0.1]->           in tChoose 'c' t a}-> in audition (out 0 (o * 0.1))
− Help/UGen/Oscillator/tGrains.help.lhs
@@ -1,52 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "TGrains"-> Sound.SC3.UGen.DB.ugenSummary "TGrains"--> import Sound.SC3--Load audio (#10) data--> let fn = "/home/rohan/data/audio/pf-c5.aif"-> in withSC3 (async (b_allocRead 10 fn 0 0))--Mouse control--> let {tRate = mouseY KR 2 200 Exponential 0.1->     ;ctr = mouseX KR 0 (bufDur KR 10) Linear 0.1->     ;tr = impulse AR tRate 0}-> in audition (out 0 (tGrains 2 tr 10 1 ctr (4 / tRate) 0 0.25 2))--> let {b = 10->     ;rt = mouseY KR 8 120 Exponential 0.1->     ;dur = 4 / rt->     ;clk = dust 'α' AR rt->     ;r = tRand 'β' 0 0.01 clk->     ;pan = whiteNoise 'γ' KR * 0.6->     ;x = mouseX KR 0 (bufDur KR b) Linear 0.1->     ;pos = x + r}-> in audition (out 0 (tGrains 2 clk b 1 pos dur pan 0.25 2))--> let {b = 10->     ;rt = mouseY KR 2 120 Exponential 0.1->     ;dur = 1.2 / rt->     ;clk = impulse AR rt 0->     ;pos = mouseX KR 0 (bufDur KR b) Linear 0.1->     ;n0 = whiteNoise 'α' KR->     ;n1 = whiteNoise 'β' KR->     ;rate = shiftLeft 1.2 (roundTo (n0 * 3) 1)}-> in audition (out 0 (tGrains 2 clk b rate pos dur (n1 * 0.6) 0.25 2))--Demand UGens as inputs (may eventually hang scsynth?)--> let {b = 10->     ;rt = mouseY KR 2 100 Linear 0.2->     ;d e = dwhite e 1 0.1 0.2->     ;z e0 e1 = drand e0 1 (mce [dgeom e0 (diwhite e0 1 20 40) 0.1 (1 + d e0)->                                ,dgeom e1 (diwhite e1 1 20 40) 1 (1 - d e1)])->     ;clk = impulse AR rt 0->     ;dsq e xs = dseq e dinf (mce xs)->     ;rate = dsq 'α' [1,1,z 'β' 'γ',0.5,0.5,0.2,0.1,0.1,0.1,0.1] * 2 + 1->     ;pos = dsq 'δ' (take 8 (zipWith z ['ε'..] ['ζ'..]))->     ;dur = dsq 'η' [1,d 'θ',1,z 'ι' 'κ',0.5,0.5,0.1,z 'λ' 'μ'] * 2 / rt->     ;pan = dsq 'ν' [1,1,1,0.5,0.2,0.1,0,0,0] * 2 - 1->     ;amp = dsq 'ξ' [1,0,z 'ο' 'π',0,2,1,1,0.1,0.1]}-> in audition (out 0 (tGrains 2 clk b rate pos dur pan amp 2))
− Help/UGen/Oscillator/tWindex.help.lhs
@@ -1,18 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "TWindex"-> Sound.SC3.UGen.DB.ugenSummary "TWindex"--> import Sound.SC3.ID--> let {p = mce [1/5, 2/5, 2/5]->     ;a = mce [400, 500, 600]->     ;t = impulse KR 6 0->     ;i = tWindex 'α' t 0 p}-> in audition (out 0 (sinOsc AR (select i  a) 0 * 0.1))--Modulating probability values--> let {p = mce [1/4, 1/2, sinOsc KR 0.3 0 * 0.5 + 0.5]->     ;a = mce [400, 500, 600]->     ;t = impulse KR 6 0->     ;i = tWindex 'α' t 1 p}-> in audition (out 0 (sinOsc AR (select i a) 0 * 0.1))
− Help/UGen/Oscillator/twChoose.help.lhs
@@ -1,14 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "TWChoose"--# tWChoose is a composite of tWindex and select--> import Sound.SC3.ID--> let {x = mouseX KR 1 1000 Exponential 0.1->     ;d = dust 'a' AR x->     ;a = mce [sinOsc AR 220 0->              ,saw AR 440->              ,pulse AR 110 0.1]->     ;w = mce [0.5, 0.35, 0.15]->     ;o = tWChoose 'b' d a w 0}-> in audition (out 0 (o * 0.1))
− Help/UGen/Oscillator/varSaw.help.lhs
@@ -1,27 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "VarSaw"-> Sound.SC3.UGen.DB.ugenSummary "VarSaw"--> import Sound.SC3--> let {f = lfPulse KR (mce2 3 3.03) 0 0.3 * 200 + 200->     ;w = linLin (lfTri KR 1 0) (-1) 1 0 1}-> in audition (out 0 (varSaw AR f 0 w * 0.1))--Compare with lfPulse at AR--> let f = lfPulse KR 3 0 0.3 * 200 + 200-> in audition (out 0 (mce [varSaw AR f 0 0.2->                         ,lfPulse AR f 0 0.2] * 0.1))--per-note width modulation--> let {d = linLin (lfNoise2 'α' KR 0.1) (-1) 1 0.15 0.5->     ;t = impulse AR (1 / d) 0->     ;w0 = tRand 'β' 0 0.35 t->     ;w1 = tRand 'γ' 0.65 1 t->     ;w = phasor AR t ((w1 - w0) * sampleDur) w0 w1 0->     ;e = decay2 t 0.1 d->     ;f = midiCPS (tRand 'δ' 36 72 t)->     ;o = varSaw AR f 0 w * e * 0.1->     ;l = tRand 'ε' (-1) 1 t}-> in audition (out 0 (pan2 o l 1))
− Help/UGen/Oscillator/vibrato.help.lhs
@@ -1,42 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Vibrato"-> Sound.SC3.UGen.DB.ugenSummary "Vibrato"--> import Sound.SC3.ID--vibrato at 1 Hz, note the use of DC.ar--{SinOsc.ar(Vibrato.ar(DC.ar(400.0),1,0.02))*0.1}.play--> let v = vibrato AR (dc AR 400) 1 0.02 0 0 0.04 0.1 0-> in audition (out 0 (sinOsc AR v 0 * 0.1))--compare: k-rate freq input can be a constant--{SinOsc.ar(Vibrato.kr(400.0,1,0.02))}.play--> let v = vibrato KR 400 1 0.02 0 0 0.04 0.1 0-> in audition (out 0 (sinOsc AR v 0 * 0.1))--control rate and rateVariation-{x=MouseX.kr(2.0,100.0)-;y=MouseY.kr(0.0,1.0)-;v=Vibrato.ar(DC.ar(400.0),x,0.1,1.0,1.0,y,0.1)-;SinOsc.ar(v)}.play-> let {x = mouseX KR 2 100 Linear 0.2->     ;y = mouseY KR 0 1 Linear 0.2->     ;v = vibrato AR (dc AR 400) x 0.1 1 1 y 0.1 0}-> in audition (out 0 (sinOsc AR v 0 * 0.1))--control depth and depthVariation--{n=LFNoise1.kr(1,3,7)-;x=MouseX.kr(0.0,1.0)-;y=MouseY.kr(0.0,1.0)-;v=Vibrato.ar(DC.ar(400.0),n,x,1.0,1.0,y,0.1)-;SinOsc.ar(v)}.play--> let {n = lfNoise1 'a' KR 1 * 3 + 7->     ;x = mouseX KR 0 1 Linear 0.2->     ;y = mouseY KR 0 1 Linear 0.2->     ;v = vibrato AR (dc AR 400) n x 1 1 y 0.1 0}-> in audition (out 0 (sinOsc AR v 0 * 0.1))
− Help/UGen/Panner/balance2.help.lhs
@@ -1,37 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Balance2"-> Sound.SC3.UGen.DB.ugenSummary "Balance2"--> import Sound.SC3.ID--{Balance2.ar(LFSaw.ar(44),Pulse.ar(33),FSinOsc.kr(0.5),0.1)}.play-> let {l = lfSaw AR 44 0->     ;r = pulse AR 33 0.5->     ;p = fSinOsc KR 0.5 0->     ;o = balance2 l r p 0.1}-> in audition (out 0 o)--{var s=SinOsc.ar([440,550]);Balance2.ar(s[0],s[1],LFNoise0.kr(4),0.3)}.play-> let {[s0,s1] = mceChannels (sinOsc AR (mce2 440 550) 0)->     ;n = lfNoise0 'a' KR 4->     ;o = balance2 s0 s1 n 0.3}-> in audition (out 0 o)--{var s=SinOsc.ar(440);Out.ar(0,0.2*Balance2.ar(s,s,SinOsc.kr(0.2)))}.play-> let {s = sinOsc AR 440 0->     ;p = sinOsc KR 0.2 0->     ;o = balance2 s s p 1 * 0.2}-> in audition (out 0 o) {- >> Sound.SC3.UGen.Dot.draw (out 0 o) -}--{var s=SinOsc.ar(440);Out.ar(0,Balance2.ar(s,s,SinOsc.kr(0.2),0.2))}.play-> let {s = sinOsc AR 440 0->     ;p = sinOsc KR 0.2 0->     ;o = balance2 s s p 0.2}-> in audition (out 0 o) {- >> Sound.SC3.UGen.Dot.draw (out 0 o) -}--> withSC3 (send (n_trace [-1]))--{var s=SinOsc.ar(440);Out.ar(0,Balance2.ar(s,s,MouseX.kr(-1,1),0.2))}.play-> let {s0 = sinOsc AR 440 0->     ;s1 = sinOsc AR 550 0->     ;x = mouseX KR (-1) 1 Linear 0.2}-> in audition (out 0 (balance2 s0 s0 x 0.2))
− Help/UGen/Panner/decodeB2.help.lhs
@@ -1,12 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "DecodeB2"-> Sound.SC3.UGen.DB.ugenSummary "DecodeB2"--> import Sound.SC3.ID--fails..., but so does sclang...-> let {p = pinkNoise 'a' AR->     ;mx = mouseX KR (-1) 1 Linear 0.2->     ;my = mouseY KR 0 0.1 Linear 0.2->     ;[w,x,y] = mceChannels (panB2 p mx my)->     ;o = decodeB2 2 w x y 0.5}-> in audition (out 0 o)
− Help/UGen/Panner/linPan2.help.lhs
@@ -1,9 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "LinPan2"-> Sound.SC3.UGen.DB.ugenSummary "LinPan2"--> import Sound.SC3.ID--> let n = pinkNoise 'a' AR-> in audition (out 0 (linPan2 n (fSinOsc KR 2 0) 0.1))--> audition (out 0 (linPan2 (fSinOsc AR 800 0) (fSinOsc KR 3 0) 0.1))
− Help/UGen/Panner/pan2.help.lhs
@@ -1,12 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Pan2"-> Sound.SC3.UGen.DB.ugenSummary "Pan2"--> import Sound.SC3.ID--> let n = pinkNoise 'a' AR-> in audition (out 0 (pan2 n (fSinOsc KR 2 0) 0.3))--> let {n = pinkNoise 'a' AR->     ;x = mouseX KR (-1) 1 Linear 0.2->     ;y = mouseY KR 0 1 Linear 0.2}-> in audition (out 0 (pan2 n x y))
− Help/UGen/Panner/panAz.help.lhs
@@ -1,9 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "PanAz"-> Sound.SC3.UGen.DB.ugenSummary "PanAz"--> import Sound.SC3.ID--> let {o = pinkNoise 'a' AR->     ;nc = 4->     ;fr = 0.15}-> in audition (out 0 (panAz nc o (lfSaw KR fr 0) 0.1 2 0.5))
− Help/UGen/Panner/rotate2.help.lhs
@@ -1,15 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Rotate2"-> Sound.SC3.UGen.DB.ugenSummary "Rotate2"--> import Sound.SC3.ID--Rotation of stereo sound, via LFO.-> let {x = pinkNoise 'a' AR->     ;y = lfTri AR 800 0 * lfPulse KR 3 0 0.3 * 0.2}-> in audition (out 0 (rotate2 x y (lfSaw KR 0.1 0)))--Rotation of stereo sound, via mouse.-> let {x = mix (lfSaw AR (mce [198..201]) 0 * 0.1)->     ;y = sinOsc AR 900 0 * lfPulse KR 3 0 0.3 * 0.2->     ;p = mouseX KR 0 2 Linear 0.2}-> in audition (out 0 (rotate2 x y p))
− Help/UGen/Panner/splay.help.lhs
@@ -1,50 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Splay"-splay inArray spread=1 level=1 center=0 levelComp=true--splay is a composite UGen.--> import Sound.SC3--mouse control--> let {i = 6->     ;r = map (\e -> rand e 10 20) (take i ['a'..])->     ;n = lfNoise2 'a' KR (mce r)->     ;x = mouseX KR (-1) 1 Linear 0.1->     ;y = mouseY KR 1 0 Linear 0.1->     ;ci = constant . fromIntegral->     ;f = mce [1 .. ci i] + 3 * 100->     ;o = sinOsc AR (n * 200 + f) 0}-> in audition (out 0 (splay o y 0.2 x True))--n_set control--> let {i = 10->     ;s = control KR "spread" 1->     ;l = control KR "level" 0.2->     ;c = control KR "center" 0->     ;r = map (\e -> rand e 10 20) (take i ['a'..])->     ;ci = constant . fromIntegral->     ;f = mce [1 .. ci i] + 3 * 100->     ;n = lfNoise2 'a' KR (mce r) * 200 + f}-> in audition (out 0 (splay (sinOsc AR n 0) s l c True))--full stereo--> withSC3 (send (n_set (-1) [("spread",1),("center",0)]))--less wide--> withSC3 (send (n_set (-1) [("spread",0.5),("center",0)]))--mono center--> withSC3 (send (n_set (-1) [("spread",0),("center",0)]))--from center to right--> withSC3 (send (n_set (-1) [("spread",0.5),("center",0.5)]))--all left--> withSC3 (send (n_set (-1) [("spread",0),("center",-1)]))
− Help/UGen/Trigger/gate.help.lhs
@@ -1,7 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Gate"-> Sound.SC3.UGen.DB.ugenSummary "Gate"--> import Sound.SC3--> let t = lfPulse AR 1 0 0.1-> in audition (out 0 (gate (fSinOsc AR 500 0 * 0.25) t))
− Help/UGen/Trigger/inRange.help.lhs
@@ -1,10 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "InRange"-> Sound.SC3.UGen.DB.ugenSummary "InRange"--> import Sound.SC3.ID--trigger noise burst-> let {n = brownNoise 'α' AR * 0.1->     ;x = mouseX KR 1 2 Linear 0.1->     ;o = sinOsc KR x 0 * 0.2}-> in audition (out 0 (inRange o (-0.15) 0.15 * n))
− Help/UGen/Trigger/lastValue.help.lhs
@@ -1,12 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "LastValue"-> Sound.SC3.UGen.DB.ugenSummary "LastValue"--> import Sound.SC3--> let x = mouseX KR 100 400 Linear 0.1-> in audition (out 0 (sinOsc AR (lastValue x 40) 0 * 0.1))--Difference between currrent and the last changed-> let {x = mouseX KR 0.1 4 Linear 0.1->     ;f = abs (lastValue x 0.5 - x) * 400 + 200}-> in audition (out 0 (sinOsc AR f 0 * 0.2))
− Help/UGen/Trigger/mostChange.help.lhs
@@ -1,9 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "MostChange"-> Sound.SC3.UGen.DB.ugenSummary "MostChange"--> import Sound.SC3.ID--> let {n = lfNoise0 'α' KR 1->     ;x = mouseX KR 200 300 Linear 0.1->     ;f = mostChange (n * 400 + 900) x}-> in audition (out 0 (sinOsc AR f 0 * 0.1))
− Help/UGen/Trigger/peak.help.lhs
@@ -1,9 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Peak"-> Sound.SC3.UGen.DB.ugenSummary "Peak"--> import Sound.SC3.ID--> let {t = dust 'α' AR 20->     ;r = impulse AR 0.4 0->     ;f = peak t r * 500 + 200}-> in audition (out 0 (sinOsc AR f 0 * 0.2))
− Help/UGen/Trigger/phasor.help.lhs
@@ -1,51 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Phasor"-> Sound.SC3.UGen.DB.ugenSummary "Phasor"--> import Sound.SC3--phasor controls sine frequency, end frequency matches second sine.--> let {rate = mouseX KR 0.2 2 Exponential 0.1->     ;tr = impulse AR rate 0->     ;sr = sampleRate->     ;x = phasor AR tr (rate / sr) 0 1 0->     ;f = mce [linLin x 0 1 600 1000, 1000]}-> in audition (out 0 (sinOsc AR f 0 * 0.2))--Load sound file to buffer zero--> let fn = "/home/rohan/data/audio/pf-c5.aif"-> in withSC3 (async (b_allocRead 0 fn 0 0))--Phasor as phase input to bufRd--> let ph = phasor AR 0 (bufRateScale KR 0) 0 (bufFrames KR 0) 0-> in audition (out 0 (bufRdN 1 AR 0 ph Loop))--Allocate and generate (non-wavetable) buffer at index one-(see osc for wavetable oscillator)--> withSC3 (do {_ <- async (b_alloc 1 256 1)->             ;let f = [Normalise,Clear]->              in send (b_gen_sine1 1 f [1])})--Audio rate phasor oscillator as phase input to bufRd--> let {b = 1->     ;f = 440->     ;fr = bufFrames KR b->     ;rt = f * (fr / sampleRate)->     ;ph = phasor AR b (rt * bufRateScale KR b) 0 fr 0}-> in audition (out 0 (bufRdL 1 AR b ph Loop * 0.1))--Phasor as impulse with reset--> let {impulse_reset freq reset =->      let ph = phasor AR reset (freq / sampleRate) 0 1 0->      in hpz1 ph <* 0->     ;x = mouseX KR 0 1 Linear 0.2 >* 0.5->     ;ck = impulse AR 3 0->     ;im = impulse_reset 3 x->     ;x' = sinOsc AR 440 0 * x * 0.05->     ;im' = sinOsc AR 220 0 * decay2 (ck + im) 0.01 0.5 * 0.1}-> in audition (out 0 (mce2 x' im'))
− Help/UGen/Trigger/pulseCount.help.lhs
@@ -1,15 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "PulseCount"-> Sound.SC3.UGen.DB.ugenSummary "PulseCount"--> import Sound.SC3.ID {- hsc3 -}--> let c = pulseCount (impulse AR 10 0) (impulse AR 0.4 0)-> in audition (out 0 (sinOsc AR (c * 200) 0 * 0.05))--printer--> let {b = localBuf 'α' 11 1->     ;t = impulse AR 10 0->     ;p = pulseCount t 0->     ;d = demand t 0 (dbufwr 'α' (-666) b p NoLoop)}-> in audition (mrg [out 0 (dc AR 0),poll t p (label "p") 0])
− Help/UGen/Trigger/pulseDivider.help.lhs
@@ -1,10 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "PulseDivider"-> Sound.SC3.UGen.DB.ugenSummary "PulseDivider"--> import Sound.SC3--> let {p = impulse AR 8 0->     ;d = pulseDivider p (mce [4,7]) 0->     ;a = sinOsc AR 1200 0 * decay2 p 0.005 0.1->     ;b = sinOsc AR 600  0 * decay2 d 0.005 0.5}-> in audition (out 0 (a + b * 0.4))
− Help/UGen/Trigger/runningMax.help.lhs
@@ -1,14 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "RunningMax"-> Sound.SC3.UGen.DB.ugenSummary "RunningMax"--> import Sound.SC3.ID--> let {n = dust 'α' AR 20->     ;t = impulse AR 0.4 0->     ;f = runningMax n t * 500 + 200}-> in audition (out 0 (sinOsc AR f 0 * 0.2))--follow a sine lfo, reset rate controlled by mouse x-> let {t = impulse KR (mouseX KR 0.01 2 Linear 0.1) 0->     ;f = runningMax (sinOsc KR 0.2 0) t * 500 + 200}-> in audition (out 0 (sinOsc AR f 0 * 0.2))
− Help/UGen/Trigger/runningMin.help.lhs
@@ -1,16 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "RunningMin"-> Sound.SC3.UGen.DB.ugenSummary "RunningMin"--> import Sound.SC3.ID--Follow a sine lfo, reset rate controlled by mouseX-> let {o = sinOsc KR 2 0->     ;x = mouseX KR 0.01 10 Exponential 0.1->     ;t = impulse AR x 0->     ;f = runningMin o t * 500 + 200 }-> in audition (out 0 (sinOsc AR f 0 * 0.2))--> let {n = dust 'α' AR 20->     ;t = impulse AR 0.4 0->     ;f = runningMin n t * 500 + 200}-> in audition (out 0 (sinOsc AR f 0 * 0.2))
− Help/UGen/Trigger/sendReply.help.lhs
@@ -1,11 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "SendReply"-> Sound.SC3.UGen.DB.ugenSummary "SendReply"--> import Sound.SC3.ID--> let {s0 = lfNoise0 'a' KR 5->     ;s1 = lfNoise0 'b' KR 5->     ;o = sinOsc AR (s0 * 200 + 500) 0 * s1 * 0.1}-> in audition (mrg [sendReply s0 0 "/send-reply" [s0,s1],out 0 o])--> withSC3 (withNotifications (waitReply "/send-reply"))
− Help/UGen/Trigger/sendTrig.help.lhs
@@ -1,11 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "SendTrig"-> Sound.SC3.UGen.DB.ugenSummary "SendTrig"--> import Sound.SC3.ID--> let {s = lfNoise0 'α' KR 5->     ;o = sinOsc AR (s * 200 + 500) 0 * 0.1}-> in audition (mrg [sendTrig s 0 s,out 0 o])--Retrieve a single message-> withSC3 (withNotifications (waitReply "/tr"))
− Help/UGen/Trigger/setResetFF.help.lhs
@@ -1,21 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "SetResetFF"-> Sound.SC3.UGen.DB.ugenSummary "SetResetFF"--> import Sound.SC3.ID--d0 is the set trigger, d1 the reset trigger--> let {n = brownNoise 'α' AR->     ;d0 = dust 'β' AR 5->     ;d1 = dust 'γ' AR 5}-> in audition (out 0 (setResetFF d0 d1 * n * 0.2))--silence--> let tr = setResetFF (impulse KR 5 0) (impulse KR 10 0)-> in audition (out 0 (brownNoise 'α' AR * 0.1 * decay2 tr 0.01 0.05))--duty cycle--> let tr = 1 - setResetFF (impulse KR 10 0) (impulse KR 5 0)-> in audition (out 0 (brownNoise 'α' AR * 0.1 * decay2 tr 0.01 0.05))
− Help/UGen/Trigger/stepper.help.lhs
@@ -1,41 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Stepper"-> Sound.SC3.UGen.DB.ugenSummary "Stepper"--> import Sound.SC3.ID--> let {i = impulse KR 10 0->     ;f = stepper i 0 4 16 (-3) 4 * 100}-> in audition (out 0 (sinOsc AR f 0 * 0.1))--Using Stepper and BufRd for sequencing-> let {compose = foldl (flip (.)) id->     ;rvb z s =->         let f i = let dly = mce [rand (z `joinID` i `joinID` 'a') 0 0.5->                                 ,rand (z `joinID` i `joinID` 'b') 0 0.5]->                     in allpassN i 0.05 dly (rand i 1.5 2)->         in compose (replicate 5 f) s->     ;stpr = let {rate = mouseX KR 1.75 2.25 Exponential 0.1->                 ;clock = impulse KR rate 0->                 ;envl = decay2 clock 0.002 2.5->                 ;indx = stepper clock 0 0 15 1 0->                 ;freq = bufRdN 1 KR 10 indx Loop->                 ;ffreq = lag2 freq 0.1 + mce [0,0.3]->                 ;lfo = sinOsc KR 0.2 (mce [0,pi/2]) * 0.0024 + 0.0025->                 ;top = mix (lfPulse AR (freq * mce [1,1.5,2]) 0 0.3)->                 ;chn = [\s -> rlpf s ffreq 0.3 * envl->                        ,\s -> rlpf s ffreq 0.3 * envl->                        ,\s -> s * 0.5->                        ,\s -> combL s 1 (0.66 / rate) 2 * 0.8 + s->                        ,\s -> s + (rvb 'a' s * 0.3)->                        ,\s -> leakDC s 0.1->                        ,\s -> delayL s 0.1 lfo + s->                        ,\s -> onePole s 0.9]}->             in compose chn top->     ;stprInit =->      let n = [97.999,195.998,523.251,466.164,195.998->              ,233.082,87.307,391.995,87.307,261.626->              ,195.998,77.782,233.082,195.998,97.999->              ,155.563]->      in do {_ <- async (b_alloc 10 128 1)->            ;send (b_setn 10 [(0,n)])}}-> in withSC3 (stprInit >> play (out 0 stpr))
− Help/UGen/Trigger/sweep.help.lhs
@@ -1,64 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Sweep"-> Sound.SC3.UGen.DB.ugenSummary "Sweep"--> import Sound.SC3.ID--Using sweep to modulate sine frequency--> let {x = mouseX KR 0.5 20 Exponential 0.1->     ;t = impulse KR x 0->     ;f = sweep t 700 + 500}-> in audition (out 0 (sinOsc AR f 0 * 0.2))--Load audio to buffer--> let fn = "/home/rohan/data/audio/pf-c5.aif"-> in withSC3 (send (b_allocRead 0 fn 0 0))--Using sweep to index into a buffer--> let {x = mouseX KR 0.5 20 Exponential 0.1->     ;t = impulse AR x 0->     ;p = sweep t (bufSampleRate KR 0)}-> in audition (out 0 (bufRdL 1 AR 0 p NoLoop))--Backwards, variable offset--> let {n = lfNoise0 'α' KR 15->     ;x = mouseX KR 0.5 10 Exponential 0.1->     ;t = impulse AR x 0->     ;r = bufSampleRate KR 0->     ;p = sweep t (negate r) + (bufFrames KR 0 * n)}-> in audition (out 0 (bufRdL 1 AR 0 p NoLoop))--Raising rate--> let {x = mouseX KR 0.5 10 Exponential 0.1->     ;t = impulse AR x 0->     ;r = sweep t 2 + 0.5->     ;p = sweep t (bufSampleRate KR 0 * r)}-> in audition (out 0 (bufRdL 1 AR 0 p NoLoop))--f0 (sc-users, 2012-02-09)--> let {lf = range 0.01 1.25 (lfNoise2 'α' KR 1)->     ;du = duty AR lf 0 DoNothing lf->     ;tr = abs (hpz1 du) >* 0->     ;ph = sweep tr (1/du)->     ;fr = linExp ph 0 1 400 800->     ;os = sinOsc AR fr 0 * 0.2}-> in audition (out 0 os)--line segments, set start & end values, transition time and trigger.-continues past end point if not re-triggered.--> let {tr = tr_control "tr" 0->     ;st = control KR "st" 440->     ;en = control KR "en" 880->     ;tm = control KR "tm" 2->     ;rt = ((en - st) / tm)->     ;sw = sweep tr rt + st}-> in audition (out 0 (sinOsc AR sw 0 * 0.2))--> withSC3 (send (n_set (-1) [("st",660),("en",550),("tm",4),("tr",1)]))-> withSC3 (send (n_set (-1) [("st",110),("en",990),("tm",1),("tr",1)]))
− Help/UGen/Trigger/tDelay.help.lhs
@@ -1,9 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "TDelay"-> Sound.SC3.UGen.DB.ugenSummary "TDelay"--> import Sound.SC3--> let {z = impulse AR 2 0->     ;z' = tDelay z 0.5->     ;o = sinOsc AR 440 0 * 0.1}-> in audition (out 0 (mce [z * 0.1,toggleFF z' * o]))
− Help/UGen/Trigger/timer.help.lhs
@@ -1,7 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Timer"-> Sound.SC3.UGen.DB.ugenSummary "Timer"--> import Sound.SC3--> let t = impulse KR (mouseX KR 0.5 20 Exponential 0.1) 0-> in audition (out 0 (sinOsc AR (timer t * 500 + 500) 0 * 0.2))
− Help/UGen/Trigger/toggleFF.help.lhs
@@ -1,8 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "ToggleFF"-> Sound.SC3.UGen.DB.ugenSummary "ToggleFF"--> import Sound.SC3.ID--> let {t = dust 'a' AR (xLine KR 1 1000 60 DoNothing)->     ;t' = toggleFF t * 400 + 800}-> in audition (out 0 (sinOsc AR t' 0 * 0.1))
− Help/UGen/Trigger/trig.help.lhs
@@ -1,8 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Trig"-> Sound.SC3.UGen.DB.ugenSummary "Trig"--> import Sound.SC3.ID--> let {d = dust 'α' AR 1->     ;o = fSinOsc AR 800 0 * 0.5}-> in audition (out 0 (trig d 0.2 * o))
− Help/UGen/Trigger/trig1.help.lhs
@@ -1,8 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "Trig1"-> Sound.SC3.UGen.DB.ugenSummary "Trig1"--> import Sound.SC3.ID--> let {d = dust 'α' AR 1->     ;o = fSinOsc AR 800 0 * 0.2}-> in audition (out 0 (trig1 d 0.2 * o))
− Help/UGen/Wavelets/dwt.help.lhs
@@ -1,3 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "DWT"-> Sound.SC3.UGen.DB.ugenSummary "DWT"-
− Help/UGen/Wavelets/idwt.help.lhs
@@ -1,32 +0,0 @@-> Sound.SC3.UGen.Help.viewSC3Help "IDWT"-> Sound.SC3.UGen.DB.ugenSummary "IDWT"--> import Sound.SC3.ID--> let {i = whiteNoise 'α' AR * 0.05->     ;b = localBuf 'β' 1024 1->     ;c = dwt b i 0.5 0 1 0 0}-> in audition (out 0 (mce2 (idwt c 0 0 0) i))--direct synthesis via writing values to buffer (try changing wavelet-type...)-> withSC3 (async (b_alloc 10 1024 1) >> send (b_zero 10))--> let {c = fftTrigger 10 0.5 0->     ;i = idwt c (-1) 0 0}-> in audition (out 0 (i * 0.1))--> import Control.Monad.Random-> import Sound.SC3.Lang.Random.Monad--> withSC3 (send (b_zero 10))--run this to change sound: WARNING, NOISY!-> do {a <- evalRandIO (nrrand 1024 (-1) 1)->    ;withSC3 (send (b_setn 10 [(0,a)]))}--> let a = map (/ 1024) [0..1023]-> in withSC3 (send (b_setn 10 [(0,a)]))--> let a = map (\i -> 1 - i / 1024) [0..1023]-> in withSC3 (send (b_setn 10 [(0,a)]))
− Help/UGen/Wavelets/wt_FilterScale.help.lhs

file too large to diff

− Help/UGen/Wavelets/wt_TimeWipe.help.lhs

file too large to diff

+ Help/UGen/abs.help.lhs view

file too large to diff

+ Help/UGen/absDif.help.lhs view

file too large to diff

+ Help/UGen/add.help.lhs view

file too large to diff

+ Help/UGen/allpassC.help.lhs view

file too large to diff

+ Help/UGen/allpassL.help.lhs view

file too large to diff

+ Help/UGen/allpassN.help.lhs view

file too large to diff

+ Help/UGen/amClip.help.lhs view

file too large to diff

+ Help/UGen/ampComp.help.lhs view

file too large to diff

+ Help/UGen/amplitude.help.lhs view

file too large to diff

+ Help/UGen/atan2.help.lhs view

file too large to diff

+ Help/UGen/atari2600.help.lhs view

file too large to diff

+ Help/UGen/atsNoiSynth.help.lhs view

file too large to diff

+ Help/UGen/atsSynth.help.lhs view

file too large to diff

+ Help/UGen/ay.help.lhs view

file too large to diff

+ Help/UGen/bBandPass.help.lhs view

file too large to diff

+ Help/UGen/bBandStop.help.lhs view

file too large to diff

+ Help/UGen/bHiPass.help.lhs view

file too large to diff

+ Help/UGen/bHiShelf.help.lhs view

file too large to diff

+ Help/UGen/bLowPass.help.lhs view

file too large to diff

+ Help/UGen/bLowShelf.help.lhs view

file too large to diff

+ Help/UGen/bPeakEQ.help.lhs view

file too large to diff

+ Help/UGen/balance2.help.lhs view

file too large to diff

+ Help/UGen/beatTrack.help.lhs view

file too large to diff

+ Help/UGen/blip.help.lhs view

file too large to diff

+ Help/UGen/blitB3Saw.help.lhs view

file too large to diff

+ Help/UGen/blitB3Square.help.lhs view

file too large to diff

+ Help/UGen/blitB3Tri.help.lhs view

file too large to diff

+ Help/UGen/bpf.help.lhs view

file too large to diff

+ Help/UGen/bpz2.help.lhs view

file too large to diff

+ Help/UGen/brf.help.lhs view

file too large to diff

+ Help/UGen/brownNoise.help.lhs view

file too large to diff

+ Help/UGen/bufAllpassC.help.lhs view

file too large to diff

+ Help/UGen/bufAllpassL.help.lhs view

file too large to diff

+ Help/UGen/bufAllpassN.help.lhs view

file too large to diff

+ Help/UGen/bufChannels.help.lhs view

file too large to diff

+ Help/UGen/bufCombC.help.lhs view

file too large to diff

+ Help/UGen/bufCombL.help.lhs view

file too large to diff

+ Help/UGen/bufCombN.help.lhs view

file too large to diff

+ Help/UGen/bufDelayC.help.lhs view

file too large to diff

+ Help/UGen/bufDelayL.help.lhs view

file too large to diff

+ Help/UGen/bufDelayN.help.lhs view

file too large to diff

+ Help/UGen/bufDur.help.lhs view

file too large to diff

+ Help/UGen/bufFrames.help.lhs view

file too large to diff

+ Help/UGen/bufRateScale.help.lhs view

file too large to diff

+ Help/UGen/bufRd.help.lhs view

file too large to diff

+ Help/UGen/bufSampleRate.help.lhs view

file too large to diff

+ Help/UGen/bufWr.help.lhs view

file too large to diff

+ Help/UGen/cOsc.help.lhs view

file too large to diff

+ Help/UGen/changed.help.lhs view

file too large to diff

+ Help/UGen/choose.help.lhs view

file too large to diff

+ Help/UGen/clip.help.lhs view

file too large to diff

+ Help/UGen/clip2.help.lhs view

file too large to diff

+ Help/UGen/clipNoise.help.lhs view

file too large to diff

+ Help/UGen/coinGate.help.lhs view

file too large to diff

+ Help/UGen/combC.help.lhs view

file too large to diff

+ Help/UGen/combL.help.lhs view

file too large to diff

+ Help/UGen/combN.help.lhs view

file too large to diff

+ Help/UGen/compander.help.lhs view

file too large to diff

+ Help/UGen/concat.help.lhs view

file too large to diff

+ Help/UGen/controlDur.help.lhs view

file too large to diff

+ Help/UGen/controlRate.help.lhs view

file too large to diff

+ Help/UGen/convolution.help.lhs view

file too large to diff

+ Help/UGen/coyote.help.lhs view

file too large to diff

+ Help/UGen/crackle.help.lhs view

file too large to diff

+ Help/UGen/cuspL.help.lhs view

file too large to diff

+ Help/UGen/cuspN.help.lhs view

file too large to diff

+ Help/UGen/dPW3Tri.help.lhs view

file too large to diff

+ Help/UGen/dWGPlucked2.help.lhs view

file too large to diff

+ Help/UGen/dbAmp.help.lhs view

file too large to diff

+ Help/UGen/dbrown.help.lhs view

file too large to diff

+ Help/UGen/dbufrd.help.lhs view

file too large to diff

+ Help/UGen/dbufwr.help.lhs view

file too large to diff

+ Help/UGen/dc.help.lhs view

file too large to diff

+ Help/UGen/decay.help.lhs view

file too large to diff

+ Help/UGen/decay2.help.lhs view

file too large to diff

+ Help/UGen/decodeB2.help.lhs view

file too large to diff

+ Help/UGen/degreeToKey.help.lhs view

file too large to diff

+ Help/UGen/delay1.help.lhs view

file too large to diff

+ Help/UGen/delay2.help.lhs view

file too large to diff

+ Help/UGen/delayC.help.lhs view

file too large to diff

+ Help/UGen/delayL.help.lhs view

file too large to diff

+ Help/UGen/delayN.help.lhs view

file too large to diff

+ Help/UGen/demand.help.lhs view

file too large to diff

+ Help/UGen/demandEnvGen.help.lhs view

file too large to diff

+ Help/UGen/detectIndex.help.lhs view

file too large to diff

+ Help/UGen/detectSilence.help.lhs view

file too large to diff

+ Help/UGen/dfm1.help.lhs view

file too large to diff

+ Help/UGen/dgeom.help.lhs view

file too large to diff

+ Help/UGen/dibrown.help.lhs view

file too large to diff

+ Help/UGen/difSqr.help.lhs view

file too large to diff

+ Help/UGen/disintegrator.help.lhs view

file too large to diff

+ Help/UGen/diskIn.help.lhs view

file too large to diff

+ Help/UGen/diskOut.help.lhs view

file too large to diff

+ Help/UGen/distort.help.lhs view

file too large to diff

+ Help/UGen/diwhite.help.lhs view

file too large to diff

+ Help/UGen/done.help.lhs view

file too large to diff

+ Help/UGen/drand.help.lhs view

file too large to diff

+ Help/UGen/dseq.help.lhs view

file too large to diff

+ Help/UGen/dser.help.lhs view

file too large to diff

+ Help/UGen/dseries.help.lhs view

file too large to diff

+ Help/UGen/dshuf.help.lhs view

file too large to diff

+ Help/UGen/dstutter.help.lhs view

file too large to diff

+ Help/UGen/dswitch.help.lhs view

file too large to diff

+ Help/UGen/dswitch1.help.lhs view

file too large to diff

+ Help/UGen/dust.help.lhs view

file too large to diff

+ Help/UGen/dust2.help.lhs view

file too large to diff

+ Help/UGen/duty.help.lhs view

file too large to diff

+ Help/UGen/dwhite.help.lhs view

file too large to diff

+ Help/UGen/dwrand.help.lhs view

file too large to diff

+ Help/UGen/dwt.help.lhs view

file too large to diff

+ Help/UGen/dxrand.help.lhs view

file too large to diff

+ Help/UGen/dynKlang.help.lhs view

file too large to diff

+ Help/UGen/dynKlank.help.lhs view

file too large to diff

+ Help/UGen/envADSR.help.lhs view

file too large to diff

+ Help/UGen/envASR.help.lhs view

file too large to diff

+ Help/UGen/envCoord.help.lhs view

file too large to diff

+ Help/UGen/envDetect.help.lhs view

file too large to diff

+ Help/UGen/envFollow.help.lhs view

file too large to diff

+ Help/UGen/envGate.help.lhs view

file too large to diff

+ Help/UGen/envGen.help.lhs view

file too large to diff

+ Help/UGen/envLinen.help.lhs view

file too large to diff

+ Help/UGen/envPerc.help.lhs view

file too large to diff

+ Help/UGen/envSine.help.lhs view

file too large to diff

+ Help/UGen/envStep.help.lhs view

file too large to diff

+ Help/UGen/envTrapezoid.help.lhs view

file too large to diff

+ Help/UGen/envTriangle.help.lhs view

file too large to diff

+ Help/UGen/eq.help.lhs view

file too large to diff

+ Help/UGen/excess.help.lhs view

file too large to diff

+ Help/UGen/expRand.help.lhs view

file too large to diff

+ Help/UGen/fSinOsc.help.lhs view

file too large to diff

+ Help/UGen/fbSineC.help.lhs view

file too large to diff

+ Help/UGen/fbSineL.help.lhs view

file too large to diff

+ Help/UGen/fbSineN.help.lhs view

file too large to diff

+ Help/UGen/fdiv.help.lhs view

file too large to diff

+ Help/UGen/fft.help.lhs view

file too large to diff

+ Help/UGen/fftTrigger.help.lhs view

file too large to diff

+ Help/UGen/fm7.help.lhs view

file too large to diff

+ Help/UGen/fmGrain.help.lhs view

file too large to diff

+ Help/UGen/fmGrainB.help.lhs view

file too large to diff

+ Help/UGen/fold2.help.lhs view

file too large to diff

+ Help/UGen/formant.help.lhs view

file too large to diff

+ Help/UGen/formlet.help.lhs view

file too large to diff

+ Help/UGen/fos.help.lhs view

file too large to diff

+ Help/UGen/free.help.lhs view

file too large to diff

+ Help/UGen/freeSelf.help.lhs view

file too large to diff

+ Help/UGen/freeSelfWhenDone.help.lhs view

file too large to diff

+ Help/UGen/freeVerb.help.lhs view

file too large to diff

+ Help/UGen/freqShift.help.lhs view

file too large to diff

+ Help/UGen/gVerb.help.lhs view

file too large to diff

+ Help/UGen/gate.help.lhs view

file too large to diff

+ Help/UGen/gbmanL.help.lhs view

file too large to diff

+ Help/UGen/gbmanN.help.lhs view

file too large to diff

+ Help/UGen/gendy1.help.lhs view

file too large to diff

+ Help/UGen/grainBuf.help.lhs view

file too large to diff

+ Help/UGen/grainFM.help.lhs view

file too large to diff

+ Help/UGen/grainIn.help.lhs view

file too large to diff

+ Help/UGen/grainSin.help.lhs view

file too large to diff

+ Help/UGen/grayNoise.help.lhs view

file too large to diff

+ Help/UGen/gt.help.lhs view

file too large to diff

+ Help/UGen/hasher.help.lhs view

file too large to diff

+ Help/UGen/henonC.help.lhs view

file too large to diff

+ Help/UGen/henonL.help.lhs view

file too large to diff

+ Help/UGen/henonN.help.lhs view

file too large to diff

+ Help/UGen/hpf.help.lhs view

file too large to diff

+ Help/UGen/hpz1.help.lhs view

file too large to diff

+ Help/UGen/hpz2.help.lhs view

file too large to diff

+ Help/UGen/hypot.help.lhs view

file too large to diff

+ Help/UGen/iEnvGen.help.lhs view

file too large to diff

+ Help/UGen/iRand.help.lhs view

file too large to diff

+ Help/UGen/idwt.help.lhs view

file too large to diff

+ Help/UGen/ifft.help.lhs view

file too large to diff

+ Help/UGen/impulse.help.lhs view

file too large to diff

+ Help/UGen/in.help.lhs view

file too large to diff

+ Help/UGen/inFeedback.help.lhs view

file too large to diff

+ Help/UGen/inRange.help.lhs view

file too large to diff

+ Help/UGen/inTrig.help.lhs view

file too large to diff

+ Help/UGen/index.help.lhs view

file too large to diff

+ Help/UGen/indexInBetween.help.lhs view

file too large to diff

+ Help/UGen/integrator.help.lhs view

file too large to diff

+ Help/UGen/ix.md view

file too large to diff

+ Help/UGen/k2A.help.lhs view

file too large to diff

+ Help/UGen/keyState.help.lhs view

file too large to diff

+ Help/UGen/klang.help.lhs view

file too large to diff

+ Help/UGen/klank.help.lhs view

file too large to diff

+ Help/UGen/lag.help.lhs view

file too large to diff

+ Help/UGen/lag2.help.lhs view

file too large to diff

+ Help/UGen/lag3.help.lhs view

file too large to diff

+ Help/UGen/lagIn.help.lhs view

file too large to diff

+ Help/UGen/lagUD.help.lhs view

file too large to diff

+ Help/UGen/lastValue.help.lhs view

file too large to diff

+ Help/UGen/latch.help.lhs view

file too large to diff

+ Help/UGen/latoocarfianC.help.lhs view

file too large to diff

+ Help/UGen/leakDC.help.lhs view

file too large to diff

+ Help/UGen/lfBrownNoise2.help.lhs view

file too large to diff

+ Help/UGen/lfClipNoise.help.lhs view

file too large to diff

+ Help/UGen/lfCub.help.lhs view

file too large to diff

+ Help/UGen/lfGauss.help.lhs view

file too large to diff

+ Help/UGen/lfNoise0.help.lhs view

file too large to diff

+ Help/UGen/lfNoise1.help.lhs view

file too large to diff

+ Help/UGen/lfNoise2.help.lhs view

file too large to diff

+ Help/UGen/lfPar.help.lhs view

file too large to diff

+ Help/UGen/lfPulse.help.lhs view

file too large to diff

+ Help/UGen/lfSaw.help.lhs view

file too large to diff

+ Help/UGen/lfTri.help.lhs view

file too large to diff

+ Help/UGen/lfdClipNoise.help.lhs view

file too large to diff

+ Help/UGen/lfdNoise0.help.lhs view

file too large to diff

+ Help/UGen/lfdNoise1.help.lhs view

file too large to diff

+ Help/UGen/lfdNoise3.help.lhs view

file too large to diff

+ Help/UGen/limiter.help.lhs view

file too large to diff

+ Help/UGen/linCongC.help.lhs view

file too large to diff

+ Help/UGen/linCongL.help.lhs view

file too large to diff

+ Help/UGen/linCongN.help.lhs view

file too large to diff

+ Help/UGen/linExp.help.lhs view

file too large to diff

+ Help/UGen/linLin.help.lhs view

file too large to diff

+ Help/UGen/linPan2.help.lhs view

file too large to diff

+ Help/UGen/linRand.help.lhs view

file too large to diff

+ Help/UGen/linXFade2.help.lhs view

file too large to diff

+ Help/UGen/line.help.lhs view

file too large to diff

+ Help/UGen/linen.help.lhs view

file too large to diff

+ Help/UGen/localBuf.help.lhs view

file too large to diff

+ Help/UGen/localIn.help.lhs view

file too large to diff

+ Help/UGen/localOut.help.lhs view

file too large to diff

+ Help/UGen/logistic.help.lhs view

file too large to diff

+ Help/UGen/loopBuf.help.lhs view

file too large to diff

+ Help/UGen/lorenzL.help.lhs view

file too large to diff

+ Help/UGen/loudness.help.lhs view

file too large to diff

+ Help/UGen/lpcSynth.help.lhs view

file too large to diff

+ Help/UGen/lpcVals.help.lhs view

file too large to diff

+ Help/UGen/lpf.help.lhs view

file too large to diff

+ Help/UGen/lpz1.help.lhs view

file too large to diff

+ Help/UGen/lpz2.help.lhs view

file too large to diff

+ Help/UGen/lti.help.lhs view

file too large to diff

+ Help/UGen/mantissaMask.help.lhs view

file too large to diff

+ Help/UGen/max.help.lhs view

file too large to diff

+ Help/UGen/median.help.lhs view

file too large to diff

+ Help/UGen/membraneCircle.help.lhs view

file too large to diff

+ Help/UGen/membraneHexagon.help.lhs view

file too large to diff

+ Help/UGen/metro.help.lhs view

file too large to diff

+ Help/UGen/midEQ.help.lhs view

file too large to diff

+ Help/UGen/mod.help.lhs view

file too large to diff

+ Help/UGen/moogFF.help.lhs view

file too large to diff

+ Help/UGen/mostChange.help.lhs view

file too large to diff

+ Help/UGen/mouseButton.help.lhs view

file too large to diff

+ Help/UGen/mouseX.help.lhs view

file too large to diff

+ Help/UGen/mouseY.help.lhs view

file too large to diff

+ Help/UGen/mrg2.help.lhs view

file too large to diff

+ Help/UGen/mul.help.lhs view

file too large to diff

+ Help/UGen/mzPokey.help.lhs view

file too large to diff

+ Help/UGen/nRand.help.lhs view

file too large to diff

+ Help/UGen/normalizer.help.lhs view

file too large to diff

+ Help/UGen/numAudioBuses.help.lhs view

file too large to diff

+ Help/UGen/numBuffers.help.lhs view

file too large to diff

+ Help/UGen/numControlBuses.help.lhs view

file too large to diff

+ Help/UGen/numInputBuses.help.lhs view

file too large to diff

+ Help/UGen/numOutputBuses.help.lhs view

file too large to diff

+ Help/UGen/numRunningSynths.help.lhs view

file too large to diff

+ Help/UGen/offsetOut.help.lhs view

file too large to diff

+ Help/UGen/onePole.help.lhs view

file too large to diff

+ Help/UGen/oneZero.help.lhs view

file too large to diff

+ Help/UGen/onsets.help.lhs view

file too large to diff

+ Help/UGen/osc.help.lhs view

file too large to diff

+ Help/UGen/osc1.help.lhs view

file too large to diff

+ Help/UGen/oscN.help.lhs view

file too large to diff

+ Help/UGen/out.help.lhs view

file too large to diff

+ Help/UGen/packFFT.help.lhs view

file too large to diff

+ Help/UGen/pan2.help.lhs view

file too large to diff

+ Help/UGen/panAz.help.lhs view

file too large to diff

+ Help/UGen/partConv.help.lhs view

file too large to diff

+ Help/UGen/pause.help.lhs view

file too large to diff

+ Help/UGen/pauseSelf.help.lhs view

file too large to diff

+ Help/UGen/pauseSelfWhenDone.help.lhs view

file too large to diff

+ Help/UGen/peak.help.lhs view

file too large to diff

+ Help/UGen/phasor.help.lhs view

file too large to diff

+ Help/UGen/pinkNoise.help.lhs view

file too large to diff

+ Help/UGen/pitch.help.lhs view

file too large to diff

+ Help/UGen/pitchShift.help.lhs view

file too large to diff

+ Help/UGen/playBuf.help.lhs view

file too large to diff

+ Help/UGen/playBufCF.help.lhs view

file too large to diff

+ Help/UGen/pluck.help.lhs view

file too large to diff

+ Help/UGen/pmOsc.help.lhs view

file too large to diff

+ Help/UGen/poll.help.lhs view

file too large to diff

+ Help/UGen/pow.help.lhs view

file too large to diff

+ Help/UGen/pulse.help.lhs view

file too large to diff

+ Help/UGen/pulseCount.help.lhs view

file too large to diff

+ Help/UGen/pulseDivider.help.lhs view

file too large to diff

+ Help/UGen/pv_BinDelay.help.lhs view

file too large to diff

+ Help/UGen/pv_BinScramble.help.lhs view

file too large to diff

+ Help/UGen/pv_BinShift.help.lhs view

file too large to diff

+ Help/UGen/pv_BinWipe.help.lhs view

file too large to diff

+ Help/UGen/pv_BrickWall.help.lhs view

file too large to diff

+ Help/UGen/pv_BufRd.help.lhs view

file too large to diff

+ Help/UGen/pv_ConformalMap.help.lhs view

file too large to diff

+ Help/UGen/pv_Copy.help.lhs view

file too large to diff

+ Help/UGen/pv_Diffuser.help.lhs view

file too large to diff

+ Help/UGen/pv_HainsworthFoote.help.lhs view

file too large to diff

+ Help/UGen/pv_Invert.help.lhs view

file too large to diff

+ Help/UGen/pv_LocalMax.help.lhs view

file too large to diff

+ Help/UGen/pv_MagAbove.help.lhs view

file too large to diff

+ Help/UGen/pv_MagBelow.help.lhs view

file too large to diff

+ Help/UGen/pv_MagClip.help.lhs view

file too large to diff

+ Help/UGen/pv_MagFreeze.help.lhs view

file too large to diff

+ Help/UGen/pv_MagMul.help.lhs view

file too large to diff

+ Help/UGen/pv_RandComb.help.lhs view

file too large to diff

+ Help/UGen/pv_RandWipe.help.lhs view

file too large to diff

+ Help/UGen/pv_RectComb.help.lhs view

file too large to diff

+ Help/UGen/pvcollect.help.lhs view

file too large to diff

+ Help/UGen/qitch.help.lhs view

file too large to diff

+ Help/UGen/quadC.help.lhs view

file too large to diff

+ Help/UGen/quadL.help.lhs view

file too large to diff

+ Help/UGen/quadN.help.lhs view

file too large to diff

+ Help/UGen/radiansPerSample.help.lhs view

file too large to diff

+ Help/UGen/ramp.help.lhs view

file too large to diff

+ Help/UGen/rand.help.lhs view

file too large to diff

+ Help/UGen/randID.help.lhs view

file too large to diff

+ Help/UGen/randSeed.help.lhs view

file too large to diff

+ Help/UGen/recordBuf.help.lhs view

file too large to diff

+ Help/UGen/replaceOut.help.lhs view

file too large to diff

+ Help/UGen/resonz.help.lhs view

file too large to diff

+ Help/UGen/rhpf.help.lhs view

file too large to diff

+ Help/UGen/ring1.help.lhs view

file too large to diff

+ Help/UGen/ringz.help.lhs view

file too large to diff

+ Help/UGen/rlpf.help.lhs view

file too large to diff

+ Help/UGen/rossler.help.lhs view

file too large to diff

+ Help/UGen/rotate2.help.lhs view

file too large to diff

+ Help/UGen/roundUp.help.lhs view

file too large to diff

+ Help/UGen/runningMax.help.lhs view

file too large to diff

+ Help/UGen/runningMin.help.lhs view

file too large to diff

+ Help/UGen/runningSum.help.lhs view

file too large to diff

+ Help/UGen/sampleDur.help.lhs view

file too large to diff

+ Help/UGen/sampleRate.help.lhs view

file too large to diff

+ Help/UGen/saw.help.lhs view

file too large to diff

+ Help/UGen/scaleNeg.help.lhs view

file too large to diff

+ Help/UGen/schmidt.help.lhs view

file too large to diff

+ Help/UGen/select.help.lhs view

file too large to diff

+ Help/UGen/selectX.help.lhs view

file too large to diff

+ Help/UGen/sendReply.help.lhs view

file too large to diff

+ Help/UGen/sendTrig.help.lhs view

file too large to diff

+ Help/UGen/setResetFF.help.lhs view

file too large to diff

+ Help/UGen/shaper.help.lhs view

file too large to diff

+ Help/UGen/silent.help.lhs view

file too large to diff

+ Help/UGen/sinOsc.help.lhs view

file too large to diff

+ Help/UGen/sinOscFB.help.lhs view

file too large to diff

+ Help/UGen/slew.help.lhs view

file too large to diff

+ Help/UGen/slope.help.lhs view

file too large to diff

+ Help/UGen/sms.help.lhs view

file too large to diff

+ Help/UGen/softClip.help.lhs view

file too large to diff

+ Help/UGen/sos.help.lhs view

file too large to diff

+ Help/UGen/soundIn.help.lhs view

file too large to diff

+ Help/UGen/specCentroid.help.lhs view

file too large to diff

+ Help/UGen/specFlatness.help.lhs view

file too large to diff

+ Help/UGen/splay.help.lhs view

file too large to diff

+ Help/UGen/squiz.help.lhs view

file too large to diff

+ Help/UGen/stepper.help.lhs view

file too large to diff

+ Help/UGen/stkBowed.help.lhs view

file too large to diff

+ Help/UGen/stkFlute.help.lhs view

file too large to diff

+ Help/UGen/stkMandolin.help.lhs view

file too large to diff

+ Help/UGen/stkModalBar.help.lhs view

file too large to diff

+ Help/UGen/stkShakers.help.lhs view

file too large to diff

+ Help/UGen/streson.help.lhs view

file too large to diff

+ Help/UGen/subsampleOffset.help.lhs view

file too large to diff

+ Help/UGen/sum3.help.lhs view

file too large to diff

+ Help/UGen/sum4.help.lhs view

file too large to diff

+ Help/UGen/sumSqr.help.lhs view

file too large to diff

+ Help/UGen/sweep.help.lhs view

file too large to diff

+ Help/UGen/switchDelay.help.lhs view

file too large to diff

+ Help/UGen/syncSaw.help.lhs view

file too large to diff

+ Help/UGen/t2K.help.lhs view

file too large to diff

+ Help/UGen/tBetaRand.help.lhs view

file too large to diff

+ Help/UGen/tBrownRand.help.lhs view

file too large to diff

+ Help/UGen/tChoose.help.lhs view

file too large to diff

+ Help/UGen/tDelay.help.lhs view

file too large to diff

+ Help/UGen/tDuty.help.lhs view

file too large to diff

+ Help/UGen/tExpRand.help.lhs view

file too large to diff

+ Help/UGen/tGaussRand.help.lhs view

file too large to diff

+ Help/UGen/tGrains.help.lhs view

file too large to diff

+ Help/UGen/tIRand.help.lhs view

file too large to diff

+ Help/UGen/tRand.help.lhs view

file too large to diff

+ Help/UGen/tWindex.help.lhs view

file too large to diff

+ Help/UGen/tartini.help.lhs view

file too large to diff

+ Help/UGen/thresh.help.lhs view

file too large to diff

+ Help/UGen/timer.help.lhs view

file too large to diff

+ Help/UGen/toggleFF.help.lhs view

file too large to diff

+ Help/UGen/tpv.help.lhs view

file too large to diff

+ Help/UGen/trig.help.lhs view

file too large to diff

+ Help/UGen/trig1.help.lhs view

file too large to diff

+ Help/UGen/trigControl.help.lhs view

file too large to diff

+ Help/UGen/twChoose.help.lhs view

file too large to diff

+ Help/UGen/twoPole.help.lhs view

file too large to diff

+ Help/UGen/twoZero.help.lhs view

file too large to diff

+ Help/UGen/vDiskIn.help.lhs view

file too large to diff

+ Help/UGen/vOsc.help.lhs view

file too large to diff

+ Help/UGen/vOsc3.help.lhs view

file too large to diff

+ Help/UGen/varLag.help.lhs view

file too large to diff

+ Help/UGen/varSaw.help.lhs view

file too large to diff

+ Help/UGen/vibrato.help.lhs view

file too large to diff

+ Help/UGen/vosim.help.lhs view

file too large to diff

+ Help/UGen/warp1.help.lhs view

file too large to diff

+ Help/UGen/waveTerrain.help.lhs view

file too large to diff

+ Help/UGen/whiteNoise.help.lhs view

file too large to diff

+ Help/UGen/wrapIndex.help.lhs view

file too large to diff

+ Help/UGen/wt_FilterScale.help.lhs view

file too large to diff

+ Help/UGen/wt_TimeWipe.help.lhs view

file too large to diff

+ Help/UGen/xFade2.help.lhs view

file too large to diff

+ Help/UGen/xLine.help.lhs view

file too large to diff

+ Help/UGen/xOut.help.lhs view

file too large to diff

+ Help/UGen/zeroCrossing.help.lhs view

file too large to diff

+ Help/UGen/zitaRev1.help.lhs view

file too large to diff

README view

file too large to diff

Sound/SC3.hs view

file too large to diff

Sound/SC3/Common.hs view

file too large to diff

+ Sound/SC3/Common/Buffer.hs view

file too large to diff

+ Sound/SC3/Common/Buffer/Array.hs view

file too large to diff

+ Sound/SC3/Common/Buffer/Gen.hs view

file too large to diff

+ Sound/SC3/Common/Buffer/Vector.hs view

file too large to diff

+ Sound/SC3/Common/Envelope.hs view

file too large to diff

+ Sound/SC3/Common/Math.hs view

file too large to diff

+ Sound/SC3/Common/Math/Interpolate.hs view

file too large to diff

+ Sound/SC3/Common/Math/Window.hs view

file too large to diff

+ Sound/SC3/Common/Monad.hs view

file too large to diff

+ Sound/SC3/Common/Monad/Operators.hs view

file too large to diff

− Sound/SC3/Common/Monad/Syntax.hs

file too large to diff

+ Sound/SC3/Common/Prelude.hs view

file too large to diff

Sound/SC3/FD.hs view

file too large to diff

Sound/SC3/Server/Command/Completion.hs view

file too large to diff

Sound/SC3/Server/Command/Enum.hs view

file too large to diff

Sound/SC3/Server/Command/Generic.hs view

file too large to diff

Sound/SC3/Server/Command/Plain.hs view

file too large to diff

Sound/SC3/Server/Graphdef.hs view

file too large to diff

Sound/SC3/Server/Graphdef/Graph.hs view

file too large to diff

Sound/SC3/Server/Graphdef/Read.hs view

file too large to diff

Sound/SC3/Server/Help.hs view

file too large to diff

Sound/SC3/Server/NRT.hs view

file too large to diff

Sound/SC3/Server/NRT/Edit.hs view

file too large to diff

Sound/SC3/Server/Recorder.hs view

file too large to diff

Sound/SC3/Server/Status.hs view

file too large to diff

Sound/SC3/Server/Synthdef.hs view

file too large to diff

Sound/SC3/Server/Transport/FD.hs view

file too large to diff

Sound/SC3/Server/Transport/Monad.hs view

file too large to diff

Sound/SC3/UGen.hs view

file too large to diff

+ Sound/SC3/UGen/Analysis.hs view

file too large to diff

Sound/SC3/UGen/Bindings.hs view

file too large to diff

Sound/SC3/UGen/Bindings/Composite.hs view

file too large to diff

Sound/SC3/UGen/Bindings/DB.hs view

file too large to diff

Sound/SC3/UGen/Bindings/HW.hs view

file too large to diff

Sound/SC3/UGen/Bindings/HW/Construct.hs view

file too large to diff

Sound/SC3/UGen/Bindings/HW/External.hs view

file too large to diff

− Sound/SC3/UGen/Bindings/HW/External/ATS.hs

file too large to diff

− Sound/SC3/UGen/Bindings/HW/External/ID.hs

file too large to diff

− Sound/SC3/UGen/Bindings/HW/External/LPC.hs

file too large to diff

Sound/SC3/UGen/Bindings/HW/External/SC3_Plugins.hs view

file too large to diff

Sound/SC3/UGen/Enum.hs view

file too large to diff

Sound/SC3/UGen/Envelope.hs view

file too large to diff

− Sound/SC3/UGen/Envelope/Construct.hs

file too large to diff

− Sound/SC3/UGen/Envelope/Interpolate.hs

file too large to diff

Sound/SC3/UGen/Graph.hs view

file too large to diff

Sound/SC3/UGen/Graph/Reconstruct.hs view

file too large to diff

Sound/SC3/UGen/Graph/Transform.hs view

file too large to diff

+ Sound/SC3/UGen/HS.hs view

file too large to diff

Sound/SC3/UGen/Help.hs view

file too large to diff

Sound/SC3/UGen/Help/Graph.hs view

file too large to diff

Sound/SC3/UGen/MCE.hs view

file too large to diff

Sound/SC3/UGen/Math.hs view

file too large to diff

+ Sound/SC3/UGen/Math/Composite.hs view

file too large to diff

Sound/SC3/UGen/Name.hs view

file too large to diff

Sound/SC3/UGen/Operator.hs view

file too large to diff

Sound/SC3/UGen/Plain.hs view

file too large to diff

Sound/SC3/UGen/Type.hs view

file too large to diff

Sound/SC3/UGen/UGen.hs view

file too large to diff

Sound/SC3/UGen/UId.hs view

file too large to diff

emacs/hsc3.el view

file too large to diff

hsc3.cabal view

file too large to diff