Safe Haskell | None |
---|---|
Language | Haskell98 |
- data Sig
- unSig :: Sig -> GE E
- data D
- unD :: D -> GE E
- data Tab
- unTab :: Tab -> GE E
- newtype Str = Str {}
- newtype Spec = Spec {}
- newtype Wspec = Wspec {}
- data BoolSig
- = BoolSig (GE E)
- | PrimBoolSig Bool
- unBoolSig :: BoolSig -> GE E
- data BoolD
- unBoolD :: BoolD -> GE E
- newtype Unit = Unit {}
- unit :: Unit
- class Val a where
- hideGE :: Val a => GE a -> a
- class (IsPrim a, RealFrac (PrimOf a), Val a) => SigOrD a
- preTab :: TabSize -> Int -> TabArgs -> Tab
- data TabSize
- = SizePlain Int
- | SizeDegree {
- hasGuardPoint :: Bool
- sizeDegree :: Int
- data TabArgs
- = ArgsPlain [Double]
- | ArgsRelative [Double]
- | ArgsGen16 [Double]
- | FileAccess String [Double]
- updateTabSize :: (TabSize -> TabSize) -> Tab -> Tab
- fromPreTab :: PreTab -> GE Gen
- getPreTabUnsafe :: String -> Tab -> PreTab
- skipNorm :: Tab -> Tab
- forceNorm :: Tab -> Tab
- nsamp :: Tab -> D
- ftlen :: Tab -> D
- ftchnls :: Tab -> D
- ftsr :: Tab -> D
- ftcps :: Tab -> D
- double :: Double -> D
- int :: Int -> D
- text :: String -> Str
- idur :: D
- getSampleRate :: D
- getControlRate :: D
- getBlockSize :: D
- getZeroDbfs :: D
- ar :: Sig -> Sig
- kr :: Sig -> Sig
- ir :: Sig -> D
- sig :: D -> Sig
- on0 :: Val a => E -> a
- on1 :: (Val a, Val b) => (E -> E) -> a -> b
- on2 :: (Val a, Val b, Val c) => (E -> E -> E) -> a -> b -> c
- on3 :: (Val a, Val b, Val c, Val d) => (E -> E -> E -> E) -> a -> b -> c -> d
- quot' :: SigOrD a => a -> a -> a
- rem' :: SigOrD a => a -> a -> a
- div' :: SigOrD a => a -> a -> a
- mod' :: SigOrD a => a -> a -> a
- ceil' :: SigOrD a => a -> a
- floor' :: SigOrD a => a -> a
- round' :: SigOrD a => a -> a
- int' :: SigOrD a => a -> a
- frac' :: SigOrD a => a -> a
- when1 :: BoolSig -> SE () -> SE ()
- whens :: [(BoolSig, SE ())] -> SE () -> SE ()
- untilDo :: BoolSig -> SE () -> SE ()
- whileDo :: BoolSig -> SE () -> SE ()
- boolSig :: BoolD -> BoolSig
Documentation
Signals
Floating Sig | |
Fractional Sig | |
Num Sig | |
Num Sig8 | |
Num Sig6 | |
Num Sig4 | |
Num Sig3 | |
Num Sig2 | |
IfB Sig | |
EqB Sig | |
OrdB Sig | |
Monoid Sig | |
Default Sig | |
SigOrD Sig | |
Val Sig | |
Sigs Sig | |
Sigs Sig8 | |
Sigs Sig6 | |
Sigs Sig4 | |
Sigs Sig2 | |
Tuple Sig | |
PureSingle Sig | |
DirtySingle (SE Sig) | |
Num (Sig8, Sig8) | |
Sigs (Sig8, Sig8) | |
DirtyMulti b => DirtyMulti ([Sig] -> b) | |
DirtyMulti b => DirtyMulti (Sig -> b) | |
PureMulti b => PureMulti ([Sig] -> b) | |
PureMulti b => PureMulti (Sig -> b) | |
Procedure b => Procedure ([Sig] -> b) | |
Procedure b => Procedure (Sig -> b) | |
DirtySingle b => DirtySingle ([Sig] -> b) | |
DirtySingle b => DirtySingle (Sig -> b) | |
PureSingle b => PureSingle ([Sig] -> b) | |
PureSingle b => PureSingle (Sig -> b) | |
Num (Sig8, Sig8, Sig8, Sig8) | |
Sigs (Sig8, Sig8, Sig8, Sig8) | |
type BooleanOf Sig = BoolSig | |
type Snap Sig = D |
Constant numbers
Floating D | |
Fractional D | |
Num D | |
IfB D | |
EqB D | |
OrdB D | |
Monoid D | |
Default D | |
SigOrD D | |
Val D | |
Arg D | |
Tuple D | |
PureSingle D | |
DirtySingle (SE D) | |
DirtyMulti b => DirtyMulti ([D] -> b) | |
DirtyMulti b => DirtyMulti (D -> b) | |
PureMulti b => PureMulti ([D] -> b) | |
PureMulti b => PureMulti (D -> b) | |
Procedure b => Procedure ([D] -> b) | |
Procedure b => Procedure (D -> b) | |
DirtySingle b => DirtySingle ([D] -> b) | |
DirtySingle b => DirtySingle (D -> b) | |
PureSingle b => PureSingle ([D] -> b) | |
PureSingle b => PureSingle (D -> b) | |
type BooleanOf D = BoolD | |
type Snap D = D |
Tables (or arrays)
IfB Tab | |
Default Tab | |
Val Tab | |
Arg Tab | |
Tuple Tab | |
PureSingle Tab | |
DirtySingle (SE Tab) | |
DirtyMulti b => DirtyMulti (Tab -> b) | |
PureMulti b => PureMulti (Tab -> b) | |
Procedure b => Procedure (Tab -> b) | |
DirtySingle b => DirtySingle (Tab -> b) | |
PureSingle b => PureSingle (Tab -> b) | |
type BooleanOf Tab = BoolD | |
type Snap Tab = Tab |
Strings
IfB Str | |
Default Str | |
Val Str | |
Arg Str | |
Tuple Str | |
PureSingle Str | |
DirtySingle (SE Str) | |
DirtyMulti b => DirtyMulti (Str -> b) | |
PureMulti b => PureMulti (Str -> b) | |
Procedure b => Procedure (Str -> b) | |
DirtySingle b => DirtySingle (Str -> b) | |
PureSingle b => PureSingle (Str -> b) | |
type BooleanOf Str = BoolD | |
type Snap Str = Str |
Spectrum. It's fsig
in the Csound.
IfB Spec | |
Default Spec | |
Val Spec | |
Tuple Spec | |
PureSingle Spec | |
DirtySingle (SE Spec) | |
DirtyMulti b => DirtyMulti (Spec -> b) | |
PureMulti b => PureMulti (Spec -> b) | |
Procedure b => Procedure (Spec -> b) | |
DirtySingle b => DirtySingle (Spec -> b) | |
PureSingle b => PureSingle (Spec -> b) | |
type BooleanOf Spec = BoolD |
Another type for spectrum. It's wsig
in the Csound.
Val Wspec | |
PureSingle Wspec | |
DirtySingle (SE Wspec) | |
DirtyMulti b => DirtyMulti (Wspec -> b) | |
PureMulti b => PureMulti (Wspec -> b) | |
Procedure b => Procedure (Wspec -> b) | |
DirtySingle b => DirtySingle (Wspec -> b) | |
PureSingle b => PureSingle (Wspec -> b) |
Csound's empty tuple.
Contains all Csound values.
Tables
fromPreTab :: PreTab -> GE Gen Source
getPreTabUnsafe :: String -> Tab -> PreTab Source
forceNorm :: Tab -> Tab Source
Force normalization (sets table size to positive value).
Might be useful to restore normalization for table doubles
.
nsamp — Returns the number of samples loaded into a stored function table number.
nsamp(x) (init-rate args only)
csound doc: http://www.csounds.com/manual/html/nsamp.html
constructors
constants
getSampleRate :: D Source
getBlockSize :: D Source
getZeroDbfs :: D Source