| Safe Haskell | None |
|---|---|
| Language | Haskell98 |
Csound.Types
Contents
Description
The Csound types.
There are several primitive types:
Sig- signalsD- numbersStr- stringsTab- 1-dimensional arraysSpecandWspec- sound spectrums
A signal is a stream of numbers. Signals carry sound or time varied control values. Numbers are constants. 1-dimensional arrays contain some useful data which is calculated at the initial run of the program.
There is only one compound type. It's a tuple of Csound values. The empty tuple
is signified with special type called Unit.
- data Sig :: *
- data D :: *
- data Tab :: *
- data Str :: *
- data Spec :: *
- data Wspec :: *
- data BoolSig :: *
- data BoolD :: *
- class Val a where
- class (IsPrim a, RealFrac (PrimOf a), Val a) => SigOrD a
- type Sig2 = (Sig, Sig)
- type Sig3 = (Sig, Sig, Sig)
- type Sig4 = (Sig, Sig, Sig, Sig)
- type Sig5 = (Sig, Sig, Sig, Sig, Sig)
- type Sig6 = (Sig, Sig, Sig, Sig, Sig, Sig)
- type Sig8 = (Sig, Sig, Sig, Sig, Sig, Sig, Sig, Sig)
- type Sig2_2 = (Sig2, Sig2)
- type Sig2_3 = (Sig2, Sig2, Sig2)
- type Sig2_4 = (Sig2, Sig2, Sig2, Sig2)
- type Sig2_5 = (Sig2, Sig2, Sig2, Sig2, Sig2)
- type Sig2_6 = (Sig2, Sig2, Sig2, Sig2, Sig2, Sig2)
- type Sig2_7 = (Sig2, Sig2, Sig2, Sig2, Sig2, Sig2, Sig2)
- type Sig2_8 = (Sig2, Sig2, Sig2, Sig2, Sig2, Sig2, Sig2, Sig2)
- double :: Double -> D
- int :: Int -> D
- text :: String -> Str
- idur :: D
- getSampleRate :: D
- getControlRate :: D
- getBlockSize :: D
- getBpm :: Sig
- setBpm :: Sig -> SE ()
- syn :: Sig -> Sig
- takt :: Sig -> Sig
- ar :: Sig -> Sig
- kr :: Sig -> Sig
- ir :: Sig -> D
- sig :: D -> Sig
- withInits :: (Tuple a, Tuple b) => a -> b -> a
- withDs :: Tuple a => a -> [D] -> a
- withSigs :: Tuple a => a -> [Sig] -> a
- withTabs :: Tuple a => a -> [Tab] -> a
- withD :: Tuple a => a -> D -> a
- withSig :: Tuple a => a -> Sig -> a
- withTab :: Tuple a => a -> Tab -> a
- withSeed :: SE Sig -> D -> Sig
- 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
- boolSig :: BoolD -> BoolSig
- when1 :: BoolSig -> SE () -> SE ()
- whens :: [(BoolSig, SE ())] -> SE () -> SE ()
- whenElse :: BoolSig -> SE () -> SE () -> SE ()
- whenD1 :: BoolD -> SE () -> SE ()
- whenDs :: [(BoolD, SE ())] -> SE () -> SE ()
- whileDo :: BoolSig -> SE () -> SE ()
- untilDo :: BoolSig -> SE () -> SE ()
- whileDoD :: BoolD -> SE () -> SE ()
- untilDoD :: BoolD -> SE () -> SE ()
- whenElseD :: BoolD -> SE () -> SE () -> SE ()
- compareWhenD :: D -> [(D, SE ())] -> SE ()
- equalsTo :: EqB a => a -> a -> BooleanOf a
- notEqualsTo :: EqB a => a -> a -> BooleanOf a
- lessThan :: OrdB a => a -> a -> BooleanOf a
- greaterThan :: OrdB a => a -> a -> BooleanOf a
- lessThanEquals :: OrdB a => a -> a -> BooleanOf a
- greaterThanEquals :: OrdB a => a -> a -> BooleanOf a
- ar1 :: Sig -> Sig
- ar2 :: (Sig, Sig) -> (Sig, Sig)
- ar4 :: (Sig, Sig, Sig, Sig) -> (Sig, Sig, Sig, Sig)
- ar6 :: (Sig, Sig, Sig, Sig, Sig, Sig) -> (Sig, Sig, Sig, Sig, Sig, Sig)
- ar8 :: (Sig, Sig, Sig, Sig, Sig, Sig, Sig, Sig) -> (Sig, Sig, Sig, Sig, Sig, Sig, Sig, Sig)
- class Tuple a where
- makeTupleMethods :: Tuple a => (a -> b) -> (b -> a) -> TupleMethods b
- data Unit :: *
- unit :: Unit
- atTuple :: Tuple a => [a] -> Sig -> a
- ifTuple :: Tuple a => BoolSig -> a -> a -> a
- guardedTuple :: Tuple b => [(BoolSig, b)] -> b -> b
- caseTuple :: Tuple b => a -> [(a -> BoolSig, b)] -> b -> b
- class Tuple a => Arg a
- atArg :: (Tuple a, Arg a) => [a] -> D -> a
- ifArg :: (Arg a, Tuple a) => BoolD -> a -> a -> a
- guardedArg :: (Tuple b, Arg b) => [(BoolD, b)] -> b -> b
- caseArg :: (Tuple b, Arg b) => a -> [(a -> BoolD, b)] -> b -> b
- data MonoArg :: * = MonoArg {}
- type MonoAdsr = Sig -> Sig -> Sig -> Sig -> Sig
- adsrMonoSynt :: (MonoAdsr -> (Sig, Sig) -> a) -> MonoArg -> a
- monoAdsr :: MonoArg -> MonoAdsr
- class (Tuple a, Num a, Fractional a, SigSpace a, BindSig a) => Sigs a
- data Arr ix a :: * -> * -> *
- newLocalArr :: (Tuple a, Tuple ix) => [D] -> SE (Arr ix a)
- newGlobalArr :: (Tuple a, Tuple ix) => [D] -> SE (Arr ix a)
- newLocalCtrlArr :: (Tuple a, Tuple ix) => [D] -> SE (Arr ix a)
- newGlobalCtrlArr :: (Tuple a, Tuple ix) => [D] -> SE (Arr ix a)
- writeArr :: (Tuple ix, Tuple a) => Arr ix a -> ix -> a -> SE ()
- readArr :: (Tuple a, Tuple ix) => Arr ix a -> ix -> SE a
- modifyArr :: (Tuple a, Tuple ix) => Arr ix a -> ix -> (a -> a) -> SE ()
- mixArr :: (Tuple ix, Tuple a, Num a) => Arr ix a -> ix -> a -> SE ()
- type Arr1 a = Arr Sig a
- type DArr1 a = Arr D a
- type Arr2 a = Arr (Sig, Sig) a
- type DArr2 a = Arr (D, D) a
- type Arr3 a = Arr (Sig, Sig, Sig) a
- type DArr3 a = Arr (D, D, D) a
- arr1 :: SE (Arr Sig a) -> SE (Arr Sig a)
- darr1 :: SE (Arr D a) -> SE (Arr D a)
- arr2 :: SE (Arr (Sig, Sig) a) -> SE (Arr (Sig, Sig) a)
- darr2 :: SE (Arr (D, D) a) -> SE (Arr (D, D) a)
- arr3 :: SE (Arr (Sig, Sig, Sig) a) -> SE (Arr (Sig, Sig, Sig) a)
- darr3 :: SE (Arr (D, D, D) a) -> SE (Arr (D, D, D) a)
- foreachArr :: (Tuple ix, Tuple a) => Arr ix a -> ((ix, a) -> SE ()) -> SE ()
- foreachArrD :: (Tuple ix, Tuple a) => Arr ix a -> ((ix, a) -> SE ()) -> SE ()
- forRowArr :: Tuple a => Sig -> Arr Sig2 a -> ((Sig, a) -> SE ()) -> SE ()
- forColumnArr :: Tuple a => Sig -> Arr Sig2 a -> ((Sig, a) -> SE ()) -> SE ()
- forRowArrD :: Tuple a => D -> Arr D2 a -> ((D, a) -> SE ()) -> SE ()
- forColumnArrD :: Tuple a => D -> Arr D2 a -> ((D, a) -> SE ()) -> SE ()
- foldArr :: (Tuple ix, Tuple a, Tuple b) => ((ix, a) -> b -> SE b) -> b -> Arr ix a -> SE b
- foldRowArr :: (Tuple a, Tuple b) => ((Sig, a) -> b -> SE b) -> b -> Sig -> Arr Sig2 a -> SE b
- foldColumnArr :: (Tuple a, Tuple b) => ((Sig, a) -> b -> SE b) -> b -> Sig -> Arr Sig2 a -> SE b
- foldRowsArrD :: (Tuple a, Tuple b) => ((D, a) -> b -> SE b) -> b -> D -> Arr D2 a -> SE b
- foldColumnsArrD :: (Tuple a, Tuple b) => ((D, a) -> b -> SE b) -> b -> D -> Arr D2 a -> SE b
- fillLocalArr :: (Tuple a, Tuple ix) => [Int] -> [a] -> SE (Arr ix a)
- fillGlobalArr :: (Tuple a, Tuple ix) => [Int] -> [a] -> SE (Arr ix a)
- fillLocalCtrlArr :: (Tuple a, Tuple ix) => [Int] -> [a] -> SE (Arr ix a)
- fillGlobalCtrlArr :: (Tuple a, Tuple ix) => [Int] -> [a] -> SE (Arr ix a)
- maparrayNew :: Arr a b -> Str -> SE (Arr a b)
- lenarray :: SigOrD c => Arr a b -> c
- copyf2array :: Arr Sig Sig -> Tab -> SE ()
- copya2ftab :: Arr Sig Sig -> Tab -> SE ()
- minarray :: (Tuple b, Num b) => Arr a b -> SE b
- maxarray :: (Tuple b, Num b) => Arr a b -> SE b
- sumarray :: (Tuple b, Num b) => Arr a b -> SE b
- scalearray :: (Tuple b, Num b) => Arr a b -> (b, b) -> SE ()
- slicearrayNew :: Arr D a -> (D, D) -> SE (Arr D a)
- maparrayCopy :: Arr a b -> Str -> Arr a b -> SE ()
- slicearrayCopy :: Arr D a -> (D, D) -> Arr D a -> SE ()
- type SpecArr = Arr Sig Sig
- fftNew :: SpecArr -> SE SpecArr
- fftinvNew :: SpecArr -> SE SpecArr
- rfftNew :: SpecArr -> SE SpecArr
- rifftNew :: SpecArr -> SE SpecArr
- pvs2tab :: SpecArr -> Spec -> SE Sig
- tab2pvs :: SpecArr -> SE Spec
- cmplxprodNew :: SpecArr -> SpecArr -> SE SpecArr
- rect2polNew :: SpecArr -> SE SpecArr
- pol2rectNew :: SpecArr -> SE SpecArr
- pol2rect2New :: SpecArr -> SpecArr -> SE SpecArr
- windowArrayNew :: SpecArr -> SE SpecArr
- r2cNew :: SpecArr -> SE SpecArr
- c2rNew :: SpecArr -> SE SpecArr
- magsArrayNew :: SpecArr -> SE SpecArr
- phsArrayNew :: SpecArr -> SE SpecArr
- fftCopy :: SpecArr -> SpecArr -> SE ()
- fftinvCopy :: SpecArr -> SpecArr -> SE ()
- rfftCopy :: SpecArr -> SpecArr -> SE ()
- rifftCopy :: SpecArr -> SpecArr -> SE ()
- cmplxprodCopy :: SpecArr -> SpecArr -> SpecArr -> SE ()
- rect2polCopy :: SpecArr -> SpecArr -> SE ()
- pol2rectCopy :: SpecArr -> SpecArr -> SE ()
- pol2rect2Copy :: SpecArr -> SpecArr -> SpecArr -> SE ()
- windowArrayCopy :: SpecArr -> SpecArr -> SE ()
- r2cCopy :: SpecArr -> SpecArr -> SE ()
- c2rCopy :: SpecArr -> SpecArr -> SE ()
- magsArrayCopy :: SpecArr -> SpecArr -> SE ()
- phsArrayCopy :: SpecArr -> SpecArr -> SE ()
Primitive types
Signals
Instances
Constant numbers
Instances
Tables (or arrays)
Strings
Spectrum. It's fsig in the Csound.
A signal of booleans.
A constant boolean value.
Contains all Csound values.
Constructors
Constants
getSampleRate :: D #
getControlRate :: D #
getBlockSize :: D #
BPM
It's used to synchronize changes with BPM. Useful with LFO's or delay times.
Calculates seconds in ratio to global BPM.
It measures time according to changes in the BPM.
It's reciprocal to syn.
Converters
Init values
withInits :: (Tuple a, Tuple b) => a -> b -> a #
Appends initialisation arguments. It's up to user to supply arguments with the right types. For example:
oscil 0.5 440 sinWave `withInits` (0.5 :: D)
withSeed :: SE Sig -> D -> Sig #
Applies a seed to the random value.
It's equivalent to the withD but it has a special
meaning of canceling the side effect. When random
opcode is provided with seed value it's no longer
contains a side effect so we don't need to restrict it.
Numeric functions
Logic functions
whens :: [(BoolSig, SE ())] -> SE () -> SE () #
The chain of when1s. Tests all the conditions in sequence
if everything is false it invokes the procedure given in the second argument.
whenDs :: [(BoolD, SE ())] -> SE () -> SE () #
The chain of when1s. Tests all the conditions in sequence
if everything is false it invokes the procedure given in the second argument.
compareWhenD :: D -> [(D, SE ())] -> SE () Source #
Performs tree search f the first argument lies within the interval it performs the corresponding procedure.
notEqualsTo :: EqB a => a -> a -> BooleanOf a infix 4 #
greaterThan :: OrdB a => a -> a -> BooleanOf a infix 4 #
lessThanEquals :: OrdB a => a -> a -> BooleanOf a infix 4 #
greaterThanEquals :: OrdB a => a -> a -> BooleanOf a infix 4 #
Aliases
Handy for functions that return tuples to specify the utput type
(aleft, aright) = ar2 $ diskin2 "file.wav" 1
or
asig = ar1 $ diskin2 "file.wav" 1
Tuples
A tuple of Csound values.
Minimal complete definition
Methods
tupleMethods :: TupleMethods a #
Instances
| Tuple MonoArg | |
| Tuple Sig | |
| Tuple D | |
| Tuple Str | |
| Tuple Spec | |
| Tuple Unit | |
| Tuple Tab | |
| Tuple TabList | |
| Tuple TempList # | |
| Tuple Temp # | |
| (Tuple a, Tuple b) => Tuple (a, b) | |
| (Tuple a, Tuple b, Tuple c) => Tuple (a, b, c) | |
| (Tuple a, Tuple b, Tuple c, Tuple d) => Tuple (a, b, c, d) | |
| (Tuple a, Tuple b, Tuple c, Tuple d, Tuple e) => Tuple (a, b, c, d, e) | |
| (Tuple a, Tuple b, Tuple c, Tuple d, Tuple e, Tuple f) => Tuple (a, b, c, d, e, f) | |
| (Tuple a, Tuple b, Tuple c, Tuple d, Tuple e, Tuple f, Tuple g) => Tuple (a, b, c, d, e, f, g) | |
| (Tuple a, Tuple b, Tuple c, Tuple d, Tuple e, Tuple f, Tuple g, Tuple h) => Tuple (a, b, c, d, e, f, g, h) | |
makeTupleMethods :: Tuple a => (a -> b) -> (b -> a) -> TupleMethods b #
Defines instance of type class Tuple for a new type in terms of an already defined one.
atTuple :: Tuple a => [a] -> Sig -> a Source #
Gets an control/audio-rate value from the list by index.
Logic functions
guardedTuple :: Tuple b => [(BoolSig, b)] -> b -> b #
guardedB for tuples of csound values.
Instruments
An instrument is a function that takes a tpule of csound values as an argument and returns a tuple of signals as an output. The type of the instrument is:
(Arg a, Out b) => a -> b
Arguments
Instances
| Arg D | |
| Arg Str | |
| Arg Unit | |
| Arg Tab | |
| Arg TabList | |
| Arg TempList # | |
| Arg Temp # | |
| (Arg a, Arg b) => Arg (a, b) | |
| (Arg a, Arg b, Arg c) => Arg (a, b, c) | |
| (Arg a, Arg b, Arg c, Arg d) => Arg (a, b, c, d) | |
| (Arg a, Arg b, Arg c, Arg d, Arg e) => Arg (a, b, c, d, e) | |
| (Arg a, Arg b, Arg c, Arg d, Arg e, Arg f) => Arg (a, b, c, d, e, f) | |
| (Arg a, Arg b, Arg c, Arg d, Arg e, Arg f, Arg h) => Arg (a, b, c, d, e, f, h) | |
| (Arg a, Arg b, Arg c, Arg d, Arg e, Arg f, Arg h, Arg g) => Arg (a, b, c, d, e, f, h, g) | |
Logic functions
guardedArg :: (Tuple b, Arg b) => [(BoolD, b)] -> b -> b #
guardedB for constants.
Monophonic arguments
Input argument for monophonic synthesizer. It includes signals for amplitude, frequency (Cycles Per second), gate, trigger. The gate equals to 1 when any note is pressed or zero when nothing is pressed. The trigger equals to 1 at the moment when new note is pressed otherwise it's 0.
adsrMonoSynt :: (MonoAdsr -> (Sig, Sig) -> a) -> MonoArg -> a #
Turns the function that expects ADSR-function and amplitude and frequency to the function on monophonic argument.
Outputs
class (Tuple a, Num a, Fractional a, SigSpace a, BindSig a) => Sigs a #
The tuples of signals.
Instances
| Sigs Sig | |
| (Sigs a1, Sigs a2) => Sigs (a1, a2) | |
| (Sigs a1, Sigs a2, Sigs a3) => Sigs (a1, a2, a3) | |
| (Sigs a1, Sigs a2, Sigs a3, Sigs a4) => Sigs (a1, a2, a3, a4) | |
| (Sigs a1, Sigs a2, Sigs a3, Sigs a4, Sigs a5) => Sigs (a1, a2, a3, a4, a5) | |
| (Sigs a1, Sigs a2, Sigs a3, Sigs a4, Sigs a5, Sigs a6) => Sigs (a1, a2, a3, a4, a5, a6) | |
| (Sigs a1, Sigs a2, Sigs a3, Sigs a4, Sigs a5, Sigs a6, Sigs a7) => Sigs (a1, a2, a3, a4, a5, a6, a7) | |
| (Sigs a1, Sigs a2, Sigs a3, Sigs a4, Sigs a5, Sigs a6, Sigs a7, Sigs a8) => Sigs (a1, a2, a3, a4, a5, a6, a7, a8) | |
Arrays
data Arr ix a :: * -> * -> * #
Arrays. The array data type is parametrized with type of the index and the type of the value. Note that the data tpyes for indices and values can be tuples.
newLocalArr :: (Tuple a, Tuple ix) => [D] -> SE (Arr ix a) #
Creates an array that is local to the body of Csound instrument where it's defined. The array contains audio signals.
newLocalArr sizes
newGlobalArr :: (Tuple a, Tuple ix) => [D] -> SE (Arr ix a) #
Creates a global array. The array contains audio signals.
newGlobalArr sizes
newLocalCtrlArr :: (Tuple a, Tuple ix) => [D] -> SE (Arr ix a) #
Creates an array that is local to the body of Csound instrument where it's defined. The array contains control signals.
newLocalCtrlArr sizes
newGlobalCtrlArr :: (Tuple a, Tuple ix) => [D] -> SE (Arr ix a) #
Creates a global array. The array contains control signals.
newGlobalCtrlArr sizes
modifyArr :: (Tuple a, Tuple ix) => Arr ix a -> ix -> (a -> a) -> SE () #
Updates the value of the array with pure function.
Type inference helpers
arr3 :: SE (Arr (Sig, Sig, Sig) a) -> SE (Arr (Sig, Sig, Sig) a) #
Function to help the type inference.
Traverse and fold
foreachArr :: (Tuple ix, Tuple a) => Arr ix a -> ((ix, a) -> SE ()) -> SE () #
Traverses all elements of the array array and applies a procedure to each element. The procedure takes in a pair of index and the current value at the given index.
foreachArrD :: (Tuple ix, Tuple a) => Arr ix a -> ((ix, a) -> SE ()) -> SE () #
Traverses all elements of the array at the **init rate** and applies a procedure to each element. The procedure takes in a pair of index and the current value at the given index.
forRowArr :: Tuple a => Sig -> Arr Sig2 a -> ((Sig, a) -> SE ()) -> SE () #
Traverses all elements in the given row of 2D array at the signal rate and applies a procedure to all elements.
forColumnArr :: Tuple a => Sig -> Arr Sig2 a -> ((Sig, a) -> SE ()) -> SE () #
Traverses all elements in the given column of 2D array at the signal rate and applies a procedure to all elements.
forRowArrD :: Tuple a => D -> Arr D2 a -> ((D, a) -> SE ()) -> SE () #
Traverses all elements in the given row of 2D array at the init rate and applies a procedure to all elements.
forColumnArrD :: Tuple a => D -> Arr D2 a -> ((D, a) -> SE ()) -> SE () #
Traverses all elements in the given column of 2D array at the init rate and applies a procedure to all elements.
foldArr :: (Tuple ix, Tuple a, Tuple b) => ((ix, a) -> b -> SE b) -> b -> Arr ix a -> SE b #
Traverses an array and accumulates a value. We invoke the function with accumulator function, initial value and the array.
foldRowArr :: (Tuple a, Tuple b) => ((Sig, a) -> b -> SE b) -> b -> Sig -> Arr Sig2 a -> SE b #
Traverses a row in the array and accumulates a value. We invoke the function with accumulator function, initial value and the array with signal of the row number.
foldRowArr accum initValue rowId array
foldColumnArr :: (Tuple a, Tuple b) => ((Sig, a) -> b -> SE b) -> b -> Sig -> Arr Sig2 a -> SE b #
Traverses a column in the array and accumulates a value. We invoke the function with accumulator function, initial value and the array with signal of the row number.
foldColumnArr accum initValue columnId array
foldRowsArrD :: (Tuple a, Tuple b) => ((D, a) -> b -> SE b) -> b -> D -> Arr D2 a -> SE b #
Traverses a row at the **init rate** in the array and accumulates a value. We invoke the function with accumulator function, initial value and the array with signal of the row number.
foldRowArr accum initValue rowId array
foldColumnsArrD :: (Tuple a, Tuple b) => ((D, a) -> b -> SE b) -> b -> D -> Arr D2 a -> SE b #
Traverses a column at the **init rate** in the array and accumulates a value. We invoke the function with accumulator function, initial value and the array with signal of the row number.
foldColumnArr accum initValue columnId array
Array opcodes
fillLocalArr :: (Tuple a, Tuple ix) => [Int] -> [a] -> SE (Arr ix a) #
Creates an array that is local to the body of Csound instrument where it's defined. The array contains audio signals. It fills the array from the list of values (the last argument).
fillLocalArr sizes initValues = ...
fillGlobalArr :: (Tuple a, Tuple ix) => [Int] -> [a] -> SE (Arr ix a) #
Creates a global array. The array contains audio signals. It fills the array from the list of values (the last argument).
fillGlobalArr sizes initValues = ...
fillLocalCtrlArr :: (Tuple a, Tuple ix) => [Int] -> [a] -> SE (Arr ix a) #
Creates an array that is local to the body of Csound instrument where it's defined. The array contains control signals. It fills the array from the list of values (the last argument).
fillLocalCtrlArr sizes initValues = ...
fillGlobalCtrlArr :: (Tuple a, Tuple ix) => [Int] -> [a] -> SE (Arr ix a) #
Creates a global array. The array contains control signals. It fills the array from the list of values (the last argument).
fillGlobalCtrlArr sizes initValues = ...
maparrayNew :: Arr a b -> Str -> SE (Arr a b) #
Mapps all values in the array with the function.
Csound docs: http://csound.github.io/docs/manual/maparray.html
maparrayCopy :: Arr a b -> Str -> Arr a b -> SE () #
Transforms the dta of the array and copies it to the second array.
Spectral opcodes
fftNew :: SpecArr -> SE SpecArr #
Complex-to-complex Fast Fourier Transform.
csound docs: http://csound.github.io/docs/manual/fft.html
fftinvNew :: SpecArr -> SE SpecArr #
Complex-to-complex Inverse Fast Fourier Transform.
csound docs: http://csound.github.io/docs/manual/fftinv.html
rfftNew :: SpecArr -> SE SpecArr #
Fast Fourier Transform of a real-value array.
csound docs: http://csound.github.io/docs/manual/rfft.html
rifftNew :: SpecArr -> SE SpecArr #
Complex-to-real Inverse Fast Fourier Transform.
csound docs: http://csound.github.io/docs/manual/rifft.html
pvs2tab :: SpecArr -> Spec -> SE Sig #
Copies spectral data to k-rate arrays (or t-variables). Also known as pvs2array.
csound docs: http://csound.github.io/docs/manual/pvs2tab.html
tab2pvs :: SpecArr -> SE Spec #
Copies spectral data from k-rate arrays (or t-variables.). Also known as pvsfromarray.
csound docs: http://csound.github.io/docs/manual/tab2pvs.html
cmplxprodNew :: SpecArr -> SpecArr -> SE SpecArr #
Complex product of two arrays.
kout[] cmplxprod kin1[], kin2[]
csound docs: http://csound.github.io/docs/manual/cmplxprod.html
rect2polNew :: SpecArr -> SE SpecArr #
Rectangular to polar format conversion.
kout[] rect2pol kin[]
csound docs: http://csound.github.io/docs/manual/rect2pol.html
pol2rectNew :: SpecArr -> SE SpecArr #
Polar to rectangular format conversion.
kout[] pol2rect kin[]
csound docs: http://csound.github.io/docs/manual/pol2rect.html
pol2rect2New :: SpecArr -> SpecArr -> SE SpecArr #
Polar to rectangular format conversion.
kout[] pol2rect kmags[], kphs[]
csound docs: http://csound.github.io/docs/manual/pol2rect.html
windowArrayNew :: SpecArr -> SE SpecArr #
Applies a window to an array.
kout[] window kin[][, koff, itype]
csound docs: http://csound.github.io/docs/manual/window.html
r2cNew :: SpecArr -> SE SpecArr #
Real to complex format conversion.
kout[] r2c kin[]
csound docs: http://csound.github.io/docs/manual/r2c.html
c2rNew :: SpecArr -> SE SpecArr #
Complex to real format conversion.
kout[] c2r kin[]
csound docs: http://csound.github.io/docs/manual/c2r.html
magsArrayNew :: SpecArr -> SE SpecArr #
Obtains the magnitudes of a complex-number array
kout[] mags kin[]
csound docs: http://csound.github.io/docs/manual/mags.html
phsArrayNew :: SpecArr -> SE SpecArr #
Obtains the phases of a complex-number array
kout[] phs kin[]
csound docs: <http://csound.github.io/docs/manual/phs.html>
fftCopy :: SpecArr -> SpecArr -> SE () #
Complex-to-complex Fast Fourier Transform.
csound docs: http://csound.github.io/docs/manual/fft.html
fftinvCopy :: SpecArr -> SpecArr -> SE () #
Complex-to-complex Inverse Fast Fourier Transform.
csound docs: http://csound.github.io/docs/manual/fftinv.html
rfftCopy :: SpecArr -> SpecArr -> SE () #
Fast Fourier Transform of a real-value array.
csound docs: http://csound.github.io/docs/manual/rfft.html
rifftCopy :: SpecArr -> SpecArr -> SE () #
Complex-to-real Inverse Fast Fourier Transform.
csound docs: http://csound.github.io/docs/manual/rifft.html
cmplxprodCopy :: SpecArr -> SpecArr -> SpecArr -> SE () #
Complex product of two arrays.
kout[] cmplxprod kin1[], kin2[]
csound docs: http://csound.github.io/docs/manual/cmplxprod.html
rect2polCopy :: SpecArr -> SpecArr -> SE () #
Rectangular to polar format conversion.
kout[] rect2pol kin[]
csound docs: http://csound.github.io/docs/manual/rect2pol.html
pol2rectCopy :: SpecArr -> SpecArr -> SE () #
Polar to rectangular format conversion.
kout[] pol2rect kin[]
csound docs: http://csound.github.io/docs/manual/pol2rect.html
pol2rect2Copy :: SpecArr -> SpecArr -> SpecArr -> SE () #
Polar to rectangular format conversion.
kout[] pol2rect kmags[], kphs[]
csound docs: http://csound.github.io/docs/manual/pol2rect.html
windowArrayCopy :: SpecArr -> SpecArr -> SE () #
Applies a window to an array.
kout[] window kin[][, koff, itype]
csound docs: http://csound.github.io/docs/manual/window.html
r2cCopy :: SpecArr -> SpecArr -> SE () #
Real to complex format conversion.
kout[] r2c kin[]
csound docs: http://csound.github.io/docs/manual/r2c.html
c2rCopy :: SpecArr -> SpecArr -> SE () #
Complex to real format conversion.
kout[] c2r kin[]
csound docs: http://csound.github.io/docs/manual/c2r.html
magsArrayCopy :: SpecArr -> SpecArr -> SE () #
Obtains the magnitudes of a complex-number array
kout[] mags kin[]
csound docs: http://csound.github.io/docs/manual/mags.html
phsArrayCopy :: SpecArr -> SpecArr -> SE () #
Obtains the phases of a complex-number array
kout[] phs kin[]
csound docs: <http://csound.github.io/docs/manual/phs.html>