module Csound.Typed.Opcode.SignalModifiers (
    
    
    -- * Amplitude Modifiers.
    balance, clip, compress, compress2, dam, gain,
    
    -- * Convolution and Morphing.
    convolve, cross2, dconv, ftconv, ftmorf, liveconv, pconvolve, tvconv,
    
    -- * Delay.
    delay, delay1, delayk, vdel_k, delayr, delayw, deltap, deltap3, deltapi, deltapn, deltapx, deltapxw, multitap, vdelay, vdelay3, vdelayx, vdelayxq, vdelayxs, vdelayxw, vdelayxwq, vdelayxws,
    
    -- * Panning and Spatialization.
    bformdec, bformdec1, bformenc, bformenc1, hrtfearly, hrtfmove, hrtfmove2, hrtfreverb, hrtfstat, locsend, locsig, pan, pan2, space, spat3d, spat3di, spat3dt, spdist, spsend, vbap, vbap16, vbap16move, vbap4, vbap4move, vbap8, vbap8move, vbapg, vbapgmove, vbaplsinit, vbapmove, vbapz, vbapzmove,
    
    -- * Reverberation.
    alpass, babo, comb, combinv, freeverb, nestedap, nreverb, platerev, reverb, reverb2, reverbsc, valpass, vcomb,
    
    -- * Sample Level Operators.
    denorm, diff, downsamp, fold, integ, interp, ntrpol, samphold, upsamp, vaget, vaset,
    
    -- * Signal Limiters.
    limit, mirror, wrap,
    
    -- * Special Effects.
    distort, distort1, flanger, harmon, harmon2, harmon3, harmon4, phaser1, phaser2,
    
    -- * Standard Filters.
    atone, atonex, biquad, biquada, butbp, butbr, buthp, butlp, butterbp, butterbr, butterhp, butterlp, clfilt, diode_ladder, doppler, k35_hpf, k35_lpf, median, mediank, mode, tone, tonex, zdf_1pole, zdf_1pole_mode, zdf_2pole, zdf_2pole_mode, zdf_ladder,
    
    -- * Standard Filters:Resonant.
    areson, bqrez, lowpass2, lowres, lowresx, lpf18, moogladder, moogladder2, moogvcf, moogvcf2, mvchpf, mvclpf1, mvclpf2, mvclpf3, mvclpf4, reson, resonr, resonx, resony, resonz, rezzy, statevar, svfilter, tbvcf, vlowres,
    
    -- * Standard Filters:Control.
    aresonk, atonek, lineto, port, portk, resonk, resonxk, sc_lag, sc_lagud, sc_trig, tlineto, tonek,
    
    -- * Specialized Filters.
    dcblock, dcblock2, eqfil, filter2, fmanal, fofilter, hilbert, hilbert2, nlfilt, nlfilt2, pareq, rbjeq, zfilter2,
    
    -- * Waveguides.
    wguide1, wguide2,
    
    -- * Waveshaping.
    chebyshevpoly, pdclip, pdhalf, pdhalfy, powershape,
    
    -- * Comparators and Accumulators.
    cmp, max', max_k, maxabs, maxabsaccum, maxaccum, min', minabs, minabsaccum, minaccum) where

import Control.Monad.Trans.Class
import Csound.Dynamic
import Csound.Typed

-- Amplitude Modifiers.

-- | 
-- Adjust one audio signal according to the values of another.
--
-- The rms power of asig can be interrogated, set, or adjusted to match that of a comparator signal.
--
-- > ares  balance  asig, acomp [, ihp] [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/balance.html>
balance ::  Sig -> Sig -> Sig
balance :: Sig -> Sig -> Sig
balance Sig
b1 Sig
b2 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E
f (E -> E -> E) -> GE E -> GE (E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2
    where f :: E -> E -> E
f E
a1 E
a2 = Name -> Spec1 -> [E] -> E
opcs Name
"balance" [(Rate
Ar,[Rate
Ar,Rate
Ar,Rate
Ir,Rate
Ir])] [E
a1,E
a2]

-- | 
-- Clips a signal to a predefined limit.
--
-- Clips an a-rate signal to a predefined limit, in a “soft” manner, using one of three methods.
--
-- > ares  clip  asig, imeth, ilimit [, iarg]
--
-- csound doc: <http://csound.com/docs/manual/clip.html>
clip ::  Sig -> D -> D -> Sig
clip :: Sig -> D -> D -> Sig
clip Sig
b1 D
b2 D
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"clip" [(Rate
Ar,[Rate
Ar,Rate
Ir,Rate
Ir,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- Compress, limit, expand, duck or gate an audio signal.
--
-- This unit functions as an audio
--     compressor, limiter, expander, or noise gate, using either
--     soft-knee or hard-knee mapping, and with dynamically variable
--     performance characteristics.  It takes two audio input signals,
--     aasig and acsig, the first of which is modified by a running
--     analysis of the second. Both signals can be the same, or the first
--     can be modified by a different controlling signal.
--
-- > ar  compress  aasig, acsig, kthresh, kloknee, khiknee, kratio, katt, krel, ilook
--
-- csound doc: <http://csound.com/docs/manual/compress.html>
compress ::  Sig -> Sig -> Sig -> Sig -> Sig -> Sig -> Sig -> Sig -> D -> Sig
compress :: Sig -> Sig -> Sig -> Sig -> Sig -> Sig -> Sig -> Sig -> D -> Sig
compress Sig
b1 Sig
b2 Sig
b3 Sig
b4 Sig
b5 Sig
b6 Sig
b7 Sig
b8 D
b9 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E -> E -> E -> E -> E -> E
f (E -> E -> E -> E -> E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E -> E -> E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b4 GE (E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b5 GE (E -> E -> E -> E -> E) -> GE E -> GE (E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b6 GE (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b7 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b8 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b9
    where f :: E -> E -> E -> E -> E -> E -> E -> E -> E -> E
f E
a1 E
a2 E
a3 E
a4 E
a5 E
a6 E
a7 E
a8 E
a9 = Name -> Spec1 -> [E] -> E
opcs Name
"compress" [(Rate
Ar,[Rate
Ar,Rate
Ar,Rate
Kr,Rate
Kr,Rate
Kr,Rate
Kr,Rate
Kr,Rate
Kr,Rate
Ir])] [E
a1
                                                                                             ,E
a2
                                                                                             ,E
a3
                                                                                             ,E
a4
                                                                                             ,E
a5
                                                                                             ,E
a6
                                                                                             ,E
a7
                                                                                             ,E
a8
                                                                                             ,E
a9]

-- | 
-- Compress, limit, expand, duck or gate an audio signal.
--
-- This unit functions as an audio
--     compressor, limiter, expander, or noise gate, using either
--     soft-knee or hard-knee mapping, and with dynamically variable
--     performance characteristics.  It takes two audio input signals,
--     aasig and acsig, the first of which is modified by a running
--     analysis of the second. Both signals can be the same, or the first
--     can be modified by a different controlling signal.
--
-- > ar  compress2  aasig, acsig, kthresh, kloknee, khiknee, kratio, katt, krel, ilook
--
-- csound doc: <http://csound.com/docs/manual/compress2.html>
compress2 ::  Sig -> Sig -> Sig -> Sig -> Sig -> Sig -> Sig -> Sig -> D -> Sig
compress2 :: Sig -> Sig -> Sig -> Sig -> Sig -> Sig -> Sig -> Sig -> D -> Sig
compress2 Sig
b1 Sig
b2 Sig
b3 Sig
b4 Sig
b5 Sig
b6 Sig
b7 Sig
b8 D
b9 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E -> E -> E -> E -> E -> E
f (E -> E -> E -> E -> E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E -> E -> E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b4 GE (E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b5 GE (E -> E -> E -> E -> E) -> GE E -> GE (E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b6 GE (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b7 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b8 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b9
    where f :: E -> E -> E -> E -> E -> E -> E -> E -> E -> E
f E
a1 E
a2 E
a3 E
a4 E
a5 E
a6 E
a7 E
a8 E
a9 = Name -> Spec1 -> [E] -> E
opcs Name
"compress2" [(Rate
Ar,[Rate
Ar,Rate
Ar,Rate
Kr,Rate
Kr,Rate
Kr,Rate
Kr,Rate
Kr,Rate
Kr,Rate
Ir])] [E
a1
                                                                                              ,E
a2
                                                                                              ,E
a3
                                                                                              ,E
a4
                                                                                              ,E
a5
                                                                                              ,E
a6
                                                                                              ,E
a7
                                                                                              ,E
a8
                                                                                              ,E
a9]

-- | 
-- A dynamic compressor/expander.
--
-- This opcode dynamically modifies a gain value applied to the input sound ain by comparing its power level to a given threshold level. The signal will be compressed/expanded with different factors regarding that it is over or under the threshold.
--
-- > ares  dam  asig, kthreshold, icomp1, icomp2, irtime, iftime
--
-- csound doc: <http://csound.com/docs/manual/dam.html>
dam ::  Sig -> Sig -> D -> D -> D -> D -> Sig
dam :: Sig -> Sig -> D -> D -> D -> D -> Sig
dam Sig
b1 Sig
b2 D
b3 D
b4 D
b5 D
b6 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E -> E -> E
f (E -> E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> E -> E -> E) -> GE E -> GE (E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b3 GE (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b4 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b5 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b6
    where f :: E -> E -> E -> E -> E -> E -> E
f E
a1 E
a2 E
a3 E
a4 E
a5 E
a6 = Name -> Spec1 -> [E] -> E
opcs Name
"dam" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Ir,Rate
Ir,Rate
Ir,Rate
Ir])] [E
a1,E
a2,E
a3,E
a4,E
a5,E
a6]

-- | 
-- Adjusts the amplitude audio signal according to a root-mean-square value.
--
-- > ares  gain  asig, krms [, ihp] [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/gain.html>
gain ::  Sig -> Sig -> Sig
gain :: Sig -> Sig -> Sig
gain Sig
b1 Sig
b2 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E
f (E -> E -> E) -> GE E -> GE (E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2
    where f :: E -> E -> E
f E
a1 E
a2 = Name -> Spec1 -> [E] -> E
opcs Name
"gain" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Ir,Rate
Ir])] [E
a1,E
a2]

-- Convolution and Morphing.

-- | 
-- Convolves a signal and an impulse response.
--
-- Output is the convolution of signal ain and the impulse response contained in ifilcod. If more than one output signal is supplied, each will be convolved with the same impulse response. Note that it is considerably more efficient to use one instance of the operator when processing a mono input to create stereo, or quad, outputs.
--
-- > ar1 [, ar2] [, ar3] [, ar4]  convolve  ain, ifilcod [, ichannel]
--
-- csound doc: <http://csound.com/docs/manual/convolve.html>
convolve :: Tuple a => Sig -> Str -> a
convolve :: forall a. Tuple a => Sig -> Str -> a
convolve Sig
b1 Str
b2 = GE (MultiOut [E]) -> a
forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple (GE (MultiOut [E]) -> a) -> GE (MultiOut [E]) -> a
forall a b. (a -> b) -> a -> b
$ E -> E -> MultiOut [E]
f (E -> E -> MultiOut [E]) -> GE E -> GE (E -> MultiOut [E])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> MultiOut [E]) -> GE E -> GE (MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Str -> GE E
unStr Str
b2
    where f :: E -> E -> MultiOut [E]
f E
a1 E
a2 = Name -> Specs -> [E] -> MultiOut [E]
mopcs Name
"convolve" ([Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar],[Rate
Ar,Rate
Sr,Rate
Ir]) [E
a1,E
a2]

-- | 
-- Cross synthesis using FFT's.
--
-- This is an implementation of cross synthesis using FFT's.
--
-- > ares  cross2  ain1, ain2, isize, ioverlap, iwin, kbias
--
-- csound doc: <http://csound.com/docs/manual/cross2.html>
cross2 ::  Sig -> Sig -> D -> D -> D -> Sig -> Sig
cross2 :: Sig -> Sig -> D -> D -> D -> Sig -> Sig
cross2 Sig
b1 Sig
b2 D
b3 D
b4 D
b5 Sig
b6 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E -> E -> E
f (E -> E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> E -> E -> E) -> GE E -> GE (E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b3 GE (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b4 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b5 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b6
    where f :: E -> E -> E -> E -> E -> E -> E
f E
a1 E
a2 E
a3 E
a4 E
a5 E
a6 = Name -> Spec1 -> [E] -> E
opcs Name
"cross2" [(Rate
Ar,[Rate
Ar,Rate
Ar,Rate
Ir,Rate
Ir,Rate
Ir,Rate
Kr])] [E
a1,E
a2,E
a3,E
a4,E
a5,E
a6]

-- | 
-- A direct convolution opcode.
--
-- > ares  dconv  asig, isize, ifn
--
-- csound doc: <http://csound.com/docs/manual/dconv.html>
dconv ::  Sig -> D -> Tab -> Sig
dconv :: Sig -> D -> Tab -> Sig
dconv Sig
b1 D
b2 Tab
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Tab -> GE E
unTab Tab
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"dconv" [(Rate
Ar,[Rate
Ar,Rate
Ir,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- Low latency multichannel convolution, using a function table as impulse
-- 	response source.
--
-- Low latency multichannel convolution, using a function table as impulse
-- 	response source. The algorithm is to split the impulse response to
-- 	partitions of length determined by the iplen parameter, and delay and
-- 	mix partitions so that the original, full length impulse response is
-- 	reconstructed without gaps. The output delay (latency) is iplen samples,
-- 	and does not depend on the control rate, unlike in the case of other
-- 	convolve opcodes.
--
-- > a1[, a2[, a3[, ... a8]]]  ftconv  ain, ift, iplen[, iskipsamples \
-- >           [, iirlen[, iskipinit]]]
--
-- csound doc: <http://csound.com/docs/manual/ftconv.html>
ftconv :: Tuple a => Sig -> D -> D -> a
ftconv :: forall a. Tuple a => Sig -> D -> D -> a
ftconv Sig
b1 D
b2 D
b3 = GE (MultiOut [E]) -> a
forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple (GE (MultiOut [E]) -> a) -> GE (MultiOut [E]) -> a
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> MultiOut [E]
f (E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> MultiOut [E])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> MultiOut [E]) -> GE E -> GE (E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b2 GE (E -> MultiOut [E]) -> GE E -> GE (MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b3
    where f :: E -> E -> E -> MultiOut [E]
f E
a1 E
a2 E
a3 = Name -> Specs -> [E] -> MultiOut [E]
mopcs Name
"ftconv" ((Rate -> [Rate]
forall a. a -> [a]
repeat Rate
Ar),[Rate
Ar,Rate
Ir,Rate
Ir,Rate
Ir,Rate
Ir,Rate
Ir]) [E
a1,E
a2,E
a3]

-- | 
-- Morphs between multiple ftables as specified in a list.
--
-- Uses an index into a table of ftable numbers to morph between adjacent tables in the list.This morphed function is written into the table referenced by iresfn on every k-cycle.
--
-- >  ftmorf  kftndx, iftfn, iresfn
--
-- csound doc: <http://csound.com/docs/manual/ftmorf.html>
ftmorf ::  Sig -> Tab -> Tab -> SE ()
ftmorf :: Sig -> Tab -> Tab -> SE ()
ftmorf Sig
b1 Tab
b2 Tab
b3 = Dep () -> SE ()
forall a. Dep a -> SE a
SE (Dep () -> SE ()) -> Dep () -> SE ()
forall a b. (a -> b) -> a -> b
$ (E -> Dep ()
forall (m :: * -> *). Monad m => E -> DepT m ()
depT_ (E -> Dep ()) -> DepT GE E -> Dep ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<<) (DepT GE E -> Dep ()) -> DepT GE E -> Dep ()
forall a b. (a -> b) -> a -> b
$ GE E -> DepT GE E
forall (m :: * -> *) a. Monad m => m a -> DepT m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (GE E -> DepT GE E) -> GE E -> DepT GE E
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Tab -> GE E
unTab Tab
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Tab -> GE E
unTab Tab
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"ftmorf" [(Rate
Xr,[Rate
Kr,Rate
Ir,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- Partitioned convolution with dynamically reloadable impulse response
--
-- Computationally efficient, partitioned convolution, using a function table as impulse response (IR) source,
--       similar to the ftconv opcode. 
--       The liveconv opcode allows dynamic reload of IR data at any time
--       while the convolution is running, controlled by the kupdate parameter.
--       Due to the manner in which the IR is updated, the operation can be done without audio artifacts in the convolution output.
--
-- > ares  liveconv  ain, ift, iplen, kupdate, kclear
--
-- csound doc: <http://csound.com/docs/manual/liveconv.html>
liveconv ::  Sig -> D -> D -> Sig -> Sig -> Sig
liveconv :: Sig -> D -> D -> Sig -> Sig -> Sig
liveconv Sig
b1 D
b2 D
b3 Sig
b4 Sig
b5 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E -> E
f (E -> E -> E -> E -> E -> E) -> GE E -> GE (E -> E -> E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E -> E) -> GE E -> GE (E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b2 GE (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b3 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b4 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b5
    where f :: E -> E -> E -> E -> E -> E
f E
a1 E
a2 E
a3 E
a4 E
a5 = Name -> Spec1 -> [E] -> E
opcs Name
"liveconv" [(Rate
Ar,[Rate
Ar,Rate
Ir,Rate
Ir,Rate
Kr,Rate
Kr])] [E
a1,E
a2,E
a3,E
a4,E
a5]

-- | 
-- Convolution based on a uniformly partitioned overlap-save algorithm
--
-- Convolution based on a uniformly partitioned overlap-save algorithm. Compared to the convolve opcode, pconvolve has these benefits:
--
-- > ar1 [, ar2] [, ar3] [, ar4]  pconvolve  ain, ifilcod [, ipartitionsize, ichannel]
--
-- csound doc: <http://csound.com/docs/manual/pconvolve.html>
pconvolve :: Tuple a => Sig -> Str -> a
pconvolve :: forall a. Tuple a => Sig -> Str -> a
pconvolve Sig
b1 Str
b2 = GE (MultiOut [E]) -> a
forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple (GE (MultiOut [E]) -> a) -> GE (MultiOut [E]) -> a
forall a b. (a -> b) -> a -> b
$ E -> E -> MultiOut [E]
f (E -> E -> MultiOut [E]) -> GE E -> GE (E -> MultiOut [E])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> MultiOut [E]) -> GE E -> GE (MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Str -> GE E
unStr Str
b2
    where f :: E -> E -> MultiOut [E]
f E
a1 E
a2 = Name -> Specs -> [E] -> MultiOut [E]
mopcs Name
"pconvolve" ([Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar],[Rate
Ar,Rate
Sr,Rate
Ir,Rate
Ir]) [E
a1,E
a2]

-- | 
-- A time-varying convolution (FIR filter) opcode.
--
-- An opcode that takes two incoming signals and
--       interprets one of them as the coefficients of linear
--       time-variable finite impulse response filter. This is
--       implemented via direct convolution (for partition sizes of
--       1 sample) or DFT-based partitioned convolution.
--       The signals can be 'frozen' (i.e. the filter coefficients are
--       kept the same) at any point in time, at a-rate or k-rate.
--
-- > ares  tvconv  asig1, asig2, xfreez1,
-- >         xfreez2, iparts, ifils
--
-- csound doc: <http://csound.com/docs/manual/tvconv.html>
tvconv ::  Sig -> Sig -> Sig -> Sig -> D -> D -> Sig
tvconv :: Sig -> Sig -> Sig -> Sig -> D -> D -> Sig
tvconv Sig
b1 Sig
b2 Sig
b3 Sig
b4 D
b5 D
b6 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E -> E -> E
f (E -> E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> E -> E -> E) -> GE E -> GE (E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b4 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b5 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b6
    where f :: E -> E -> E -> E -> E -> E -> E
f E
a1 E
a2 E
a3 E
a4 E
a5 E
a6 = Name -> Spec1 -> [E] -> E
opcs Name
"tvconv" [(Rate
Ar,[Rate
Ar,Rate
Ar,Rate
Xr,Rate
Xr,Rate
Ir,Rate
Ir])] [E
a1,E
a2,E
a3,E
a4,E
a5,E
a6]

-- Delay.

-- | 
-- Delays an input signal by some time interval.
--
-- A signal can be read from or written into a delay path, or it can be automatically delayed by some time interval.
--
-- > ares  delay  asig, idlt [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/delay.html>
delay ::  Sig -> D -> Sig
delay :: Sig -> D -> Sig
delay Sig
b1 D
b2 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E
f (E -> E -> E) -> GE E -> GE (E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b2
    where f :: E -> E -> E
f E
a1 E
a2 = Name -> Spec1 -> [E] -> E
opcs Name
"delay" [(Rate
Ar,[Rate
Ar,Rate
Ir,Rate
Ir])] [E
a1,E
a2]

-- | 
-- Delays an input signal by one sample.
--
-- > ares  delay1  asig [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/delay1.html>
delay1 ::  Sig -> Sig
delay1 :: Sig -> Sig
delay1 Sig
b1 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E
f (E -> E) -> GE E -> GE E
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1
    where f :: E -> E
f E
a1 = Name -> Spec1 -> [E] -> E
opcs Name
"delay1" [(Rate
Ar,[Rate
Ar,Rate
Ir])] [E
a1]

-- | 
-- Delays an input signal by some time interval.
--
-- k-rate delay opcodes
--
-- > kr  delayk   ksig, idel[, imode]
--
-- csound doc: <http://csound.com/docs/manual/delayk.html>
delayk ::  Sig -> D -> Sig
delayk :: Sig -> D -> Sig
delayk Sig
b1 D
b2 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E
f (E -> E -> E) -> GE E -> GE (E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b2
    where f :: E -> E -> E
f E
a1 E
a2 = Name -> Spec1 -> [E] -> E
opcs Name
"delayk" [(Rate
Kr,[Rate
Kr,Rate
Ir,Rate
Ir])] [E
a1,E
a2]

-- | 
-- Delays an input signal by some time interval.
--
-- k-rate delay opcodes
--
-- > kr  vdel_k   ksig, kdel, imdel[, imode]
--
-- csound doc: <http://csound.com/docs/manual/delayk.html>
vdel_k ::  Sig -> Sig -> D -> Sig
vdel_k :: Sig -> Sig -> D -> Sig
vdel_k Sig
b1 Sig
b2 D
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"vdel_k" [(Rate
Kr,[Rate
Kr,Rate
Kr,Rate
Ir,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- Reads from an automatically established digital delay line.
--
-- > ares  delayr  idlt [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/delayr.html>
delayr ::  D -> SE Sig
delayr :: D -> SE Sig
delayr D
b1 = (E -> Sig) -> SE E -> SE Sig
forall a b. (a -> b) -> SE a -> SE b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ( GE E -> Sig
Sig (GE E -> Sig) -> (E -> GE E) -> E -> Sig
forall b c a. (b -> c) -> (a -> b) -> a -> c
. E -> GE E
forall a. a -> GE a
forall (m :: * -> *) a. Monad m => a -> m a
return) (SE E -> SE Sig) -> SE E -> SE Sig
forall a b. (a -> b) -> a -> b
$ DepT GE E -> SE E
forall a. Dep a -> SE a
SE (DepT GE E -> SE E) -> DepT GE E -> SE E
forall a b. (a -> b) -> a -> b
$ (E -> DepT GE E
forall (m :: * -> *). Monad m => E -> DepT m E
depT (E -> DepT GE E) -> DepT GE E -> DepT GE E
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<<) (DepT GE E -> DepT GE E) -> DepT GE E -> DepT GE E
forall a b. (a -> b) -> a -> b
$ GE E -> DepT GE E
forall (m :: * -> *) a. Monad m => m a -> DepT m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (GE E -> DepT GE E) -> GE E -> DepT GE E
forall a b. (a -> b) -> a -> b
$ E -> E
f (E -> E) -> GE E -> GE E
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> D -> GE E
unD D
b1
    where f :: E -> E
f E
a1 = Name -> Spec1 -> [E] -> E
opcs Name
"delayr" [(Rate
Ar,[Rate
Ir,Rate
Ir])] [E
a1]

-- | 
-- Writes the audio signal to a digital delay line.
--
-- >  delayw  asig
--
-- csound doc: <http://csound.com/docs/manual/delayw.html>
delayw ::  Sig -> SE ()
delayw :: Sig -> SE ()
delayw Sig
b1 = Dep () -> SE ()
forall a. Dep a -> SE a
SE (Dep () -> SE ()) -> Dep () -> SE ()
forall a b. (a -> b) -> a -> b
$ (E -> Dep ()
forall (m :: * -> *). Monad m => E -> DepT m ()
depT_ (E -> Dep ()) -> DepT GE E -> Dep ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<<) (DepT GE E -> Dep ()) -> DepT GE E -> Dep ()
forall a b. (a -> b) -> a -> b
$ GE E -> DepT GE E
forall (m :: * -> *) a. Monad m => m a -> DepT m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (GE E -> DepT GE E) -> GE E -> DepT GE E
forall a b. (a -> b) -> a -> b
$ E -> E
f (E -> E) -> GE E -> GE E
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1
    where f :: E -> E
f E
a1 = Name -> Spec1 -> [E] -> E
opcs Name
"delayw" [(Rate
Xr,[Rate
Ar])] [E
a1]

-- | 
-- Taps a delay line at variable offset times.
--
-- Tap a delay line at variable offset times.
--
-- > ares  deltap  kdlt
--
-- csound doc: <http://csound.com/docs/manual/deltap.html>
deltap ::  Sig -> SE Sig
deltap :: Sig -> SE Sig
deltap Sig
b1 = (E -> Sig) -> SE E -> SE Sig
forall a b. (a -> b) -> SE a -> SE b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ( GE E -> Sig
Sig (GE E -> Sig) -> (E -> GE E) -> E -> Sig
forall b c a. (b -> c) -> (a -> b) -> a -> c
. E -> GE E
forall a. a -> GE a
forall (m :: * -> *) a. Monad m => a -> m a
return) (SE E -> SE Sig) -> SE E -> SE Sig
forall a b. (a -> b) -> a -> b
$ DepT GE E -> SE E
forall a. Dep a -> SE a
SE (DepT GE E -> SE E) -> DepT GE E -> SE E
forall a b. (a -> b) -> a -> b
$ (E -> DepT GE E
forall (m :: * -> *). Monad m => E -> DepT m E
depT (E -> DepT GE E) -> DepT GE E -> DepT GE E
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<<) (DepT GE E -> DepT GE E) -> DepT GE E -> DepT GE E
forall a b. (a -> b) -> a -> b
$ GE E -> DepT GE E
forall (m :: * -> *) a. Monad m => m a -> DepT m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (GE E -> DepT GE E) -> GE E -> DepT GE E
forall a b. (a -> b) -> a -> b
$ E -> E
f (E -> E) -> GE E -> GE E
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1
    where f :: E -> E
f E
a1 = Name -> Spec1 -> [E] -> E
opcs Name
"deltap" [(Rate
Ar,[Rate
Kr])] [E
a1]

-- | 
-- Taps a delay line at variable offset times, uses cubic interpolation.
--
-- > ares  deltap3  xdlt
--
-- csound doc: <http://csound.com/docs/manual/deltap3.html>
deltap3 ::  Sig -> SE Sig
deltap3 :: Sig -> SE Sig
deltap3 Sig
b1 = (E -> Sig) -> SE E -> SE Sig
forall a b. (a -> b) -> SE a -> SE b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ( GE E -> Sig
Sig (GE E -> Sig) -> (E -> GE E) -> E -> Sig
forall b c a. (b -> c) -> (a -> b) -> a -> c
. E -> GE E
forall a. a -> GE a
forall (m :: * -> *) a. Monad m => a -> m a
return) (SE E -> SE Sig) -> SE E -> SE Sig
forall a b. (a -> b) -> a -> b
$ DepT GE E -> SE E
forall a. Dep a -> SE a
SE (DepT GE E -> SE E) -> DepT GE E -> SE E
forall a b. (a -> b) -> a -> b
$ (E -> DepT GE E
forall (m :: * -> *). Monad m => E -> DepT m E
depT (E -> DepT GE E) -> DepT GE E -> DepT GE E
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<<) (DepT GE E -> DepT GE E) -> DepT GE E -> DepT GE E
forall a b. (a -> b) -> a -> b
$ GE E -> DepT GE E
forall (m :: * -> *) a. Monad m => m a -> DepT m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (GE E -> DepT GE E) -> GE E -> DepT GE E
forall a b. (a -> b) -> a -> b
$ E -> E
f (E -> E) -> GE E -> GE E
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1
    where f :: E -> E
f E
a1 = Name -> Spec1 -> [E] -> E
opcs Name
"deltap3" [(Rate
Ar,[Rate
Xr])] [E
a1]

-- | 
-- Taps a delay line at variable offset times, uses interpolation.
--
-- > ares  deltapi  xdlt
--
-- csound doc: <http://csound.com/docs/manual/deltapi.html>
deltapi ::  Sig -> SE Sig
deltapi :: Sig -> SE Sig
deltapi Sig
b1 = (E -> Sig) -> SE E -> SE Sig
forall a b. (a -> b) -> SE a -> SE b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ( GE E -> Sig
Sig (GE E -> Sig) -> (E -> GE E) -> E -> Sig
forall b c a. (b -> c) -> (a -> b) -> a -> c
. E -> GE E
forall a. a -> GE a
forall (m :: * -> *) a. Monad m => a -> m a
return) (SE E -> SE Sig) -> SE E -> SE Sig
forall a b. (a -> b) -> a -> b
$ DepT GE E -> SE E
forall a. Dep a -> SE a
SE (DepT GE E -> SE E) -> DepT GE E -> SE E
forall a b. (a -> b) -> a -> b
$ (E -> DepT GE E
forall (m :: * -> *). Monad m => E -> DepT m E
depT (E -> DepT GE E) -> DepT GE E -> DepT GE E
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<<) (DepT GE E -> DepT GE E) -> DepT GE E -> DepT GE E
forall a b. (a -> b) -> a -> b
$ GE E -> DepT GE E
forall (m :: * -> *) a. Monad m => m a -> DepT m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (GE E -> DepT GE E) -> GE E -> DepT GE E
forall a b. (a -> b) -> a -> b
$ E -> E
f (E -> E) -> GE E -> GE E
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1
    where f :: E -> E
f E
a1 = Name -> Spec1 -> [E] -> E
opcs Name
"deltapi" [(Rate
Ar,[Rate
Xr])] [E
a1]

-- | 
-- Taps a delay line at variable offset times.
--
-- Tap a delay line at variable offset times.
--
-- > ares  deltapn  xnumsamps
--
-- csound doc: <http://csound.com/docs/manual/deltapn.html>
deltapn ::  Sig -> Sig
deltapn :: Sig -> Sig
deltapn Sig
b1 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E
f (E -> E) -> GE E -> GE E
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1
    where f :: E -> E
f E
a1 = Name -> Spec1 -> [E] -> E
opcs Name
"deltapn" [(Rate
Ar,[Rate
Xr])] [E
a1]

-- | 
-- Read from or write to a delay line with interpolation.
--
-- deltapx is similar to deltapi or deltap3. However, it allows higher quality interpolation. This opcode can read from and write to a delayr/delayw delay line with interpolation.
--
-- > aout  deltapx  adel, iwsize
--
-- csound doc: <http://csound.com/docs/manual/deltapx.html>
deltapx ::  Sig -> D -> SE Sig
deltapx :: Sig -> D -> SE Sig
deltapx Sig
b1 D
b2 = (E -> Sig) -> SE E -> SE Sig
forall a b. (a -> b) -> SE a -> SE b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ( GE E -> Sig
Sig (GE E -> Sig) -> (E -> GE E) -> E -> Sig
forall b c a. (b -> c) -> (a -> b) -> a -> c
. E -> GE E
forall a. a -> GE a
forall (m :: * -> *) a. Monad m => a -> m a
return) (SE E -> SE Sig) -> SE E -> SE Sig
forall a b. (a -> b) -> a -> b
$ DepT GE E -> SE E
forall a. Dep a -> SE a
SE (DepT GE E -> SE E) -> DepT GE E -> SE E
forall a b. (a -> b) -> a -> b
$ (E -> DepT GE E
forall (m :: * -> *). Monad m => E -> DepT m E
depT (E -> DepT GE E) -> DepT GE E -> DepT GE E
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<<) (DepT GE E -> DepT GE E) -> DepT GE E -> DepT GE E
forall a b. (a -> b) -> a -> b
$ GE E -> DepT GE E
forall (m :: * -> *) a. Monad m => m a -> DepT m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (GE E -> DepT GE E) -> GE E -> DepT GE E
forall a b. (a -> b) -> a -> b
$ E -> E -> E
f (E -> E -> E) -> GE E -> GE (E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b2
    where f :: E -> E -> E
f E
a1 E
a2 = Name -> Spec1 -> [E] -> E
opcs Name
"deltapx" [(Rate
Ar,[Rate
Ar,Rate
Ir])] [E
a1,E
a2]

-- | 
-- Mixes the input signal to a delay line.
--
-- deltapxw mixes the input signal to a delay line. This opcode can be mixed with reading units (deltap, deltapn, deltapi, deltap3, and deltapx) in any order; the actual delay time is the difference of the read and write time. This opcode can read from and write to a delayr/delayw delay line with interpolation.
--
-- >  deltapxw  ain, adel, iwsize
--
-- csound doc: <http://csound.com/docs/manual/deltapxw.html>
deltapxw ::  Sig -> Sig -> D -> SE ()
deltapxw :: Sig -> Sig -> D -> SE ()
deltapxw Sig
b1 Sig
b2 D
b3 = Dep () -> SE ()
forall a. Dep a -> SE a
SE (Dep () -> SE ()) -> Dep () -> SE ()
forall a b. (a -> b) -> a -> b
$ (E -> Dep ()
forall (m :: * -> *). Monad m => E -> DepT m ()
depT_ (E -> Dep ()) -> DepT GE E -> Dep ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<<) (DepT GE E -> Dep ()) -> DepT GE E -> Dep ()
forall a b. (a -> b) -> a -> b
$ GE E -> DepT GE E
forall (m :: * -> *) a. Monad m => m a -> DepT m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (GE E -> DepT GE E) -> GE E -> DepT GE E
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"deltapxw" [(Rate
Xr,[Rate
Ar,Rate
Ar,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- Multitap delay line implementation.
--
-- > ares  multitap  asig [, itime1, igain1] [, itime2, igain2] [...]
--
-- csound doc: <http://csound.com/docs/manual/multitap.html>
multitap ::  Sig -> [D] -> Sig
multitap :: Sig -> [D] -> Sig
multitap Sig
b1 [D]
b2 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> [E] -> E
f (E -> [E] -> E) -> GE E -> GE ([E] -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE ([E] -> E) -> GE [E] -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (D -> GE E) -> [D] -> GE [E]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM D -> GE E
unD [D]
b2
    where f :: E -> [E] -> E
f E
a1 [E]
a2 = Name -> Spec1 -> [E] -> E
opcs Name
"multitap" [(Rate
Ar,[Rate
Ar] [Rate] -> [Rate] -> [Rate]
forall a. [a] -> [a] -> [a]
++ (Rate -> [Rate]
forall a. a -> [a]
repeat Rate
Ir))] ([E
a1] [E] -> [E] -> [E]
forall a. [a] -> [a] -> [a]
++ [E]
a2)

-- | 
-- An interpolating variable time delay.
--
-- This is an interpolating variable time delay, it is not very different from the existing implementation (deltapi), it is only easier to use.
--
-- > ares  vdelay  asig, adel, imaxdel [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/vdelay.html>
vdelay ::  Sig -> Sig -> D -> Sig
vdelay :: Sig -> Sig -> D -> Sig
vdelay Sig
b1 Sig
b2 D
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"vdelay" [(Rate
Ar,[Rate
Ar,Rate
Ar,Rate
Ir,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- A variable time delay with cubic interpolation.
--
-- vdelay3 is experimental. It is the same as vdelay except that it uses cubic interpolation. (New in Version 3.50.)
--
-- > ares  vdelay3  asig, adel, imaxdel [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/vdelay3.html>
vdelay3 ::  Sig -> Sig -> D -> Sig
vdelay3 :: Sig -> Sig -> D -> Sig
vdelay3 Sig
b1 Sig
b2 D
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"vdelay3" [(Rate
Ar,[Rate
Ar,Rate
Ar,Rate
Ir,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- A variable delay opcode with high quality interpolation.
--
-- > aout  vdelayx  ain, adl, imd, iws [, ist]
--
-- csound doc: <http://csound.com/docs/manual/vdelayx.html>
vdelayx ::  Sig -> Sig -> D -> D -> Sig
vdelayx :: Sig -> Sig -> D -> D -> Sig
vdelayx Sig
b1 Sig
b2 D
b3 D
b4 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E
f (E -> E -> E -> E -> E) -> GE E -> GE (E -> E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b3 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b4
    where f :: E -> E -> E -> E -> E
f E
a1 E
a2 E
a3 E
a4 = Name -> Spec1 -> [E] -> E
opcs Name
"vdelayx" [(Rate
Ar,[Rate
Ar,Rate
Ar,Rate
Ir,Rate
Ir,Rate
Ir])] [E
a1,E
a2,E
a3,E
a4]

-- | 
-- A 4-channel variable delay opcode with high quality interpolation.
--
-- > aout1, aout2, aout3, aout4  vdelayxq  ain1, ain2, ain3, ain4, adl, imd, iws [, ist]
--
-- csound doc: <http://csound.com/docs/manual/vdelayxq.html>
vdelayxq ::  Sig -> Sig -> Sig -> Sig -> Sig -> D -> D -> (Sig,Sig,Sig,Sig)
vdelayxq :: Sig -> Sig -> Sig -> Sig -> Sig -> D -> D -> (Sig, Sig, Sig, Sig)
vdelayxq Sig
b1 Sig
b2 Sig
b3 Sig
b4 Sig
b5 D
b6 D
b7 = GE (MultiOut [E]) -> (Sig, Sig, Sig, Sig)
forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple (GE (MultiOut [E]) -> (Sig, Sig, Sig, Sig))
-> GE (MultiOut [E]) -> (Sig, Sig, Sig, Sig)
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E -> E -> E -> MultiOut [E]
f (E -> E -> E -> E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> E -> E -> E -> MultiOut [E])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b4 GE (E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b5 GE (E -> E -> MultiOut [E]) -> GE E -> GE (E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b6 GE (E -> MultiOut [E]) -> GE E -> GE (MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b7
    where f :: E -> E -> E -> E -> E -> E -> E -> MultiOut [E]
f E
a1 E
a2 E
a3 E
a4 E
a5 E
a6 E
a7 = Name -> Specs -> [E] -> MultiOut [E]
mopcs Name
"vdelayxq" ([Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar],[Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ir,Rate
Ir,Rate
Ir]) [E
a1
                                                                                              ,E
a2
                                                                                              ,E
a3
                                                                                              ,E
a4
                                                                                              ,E
a5
                                                                                              ,E
a6
                                                                                              ,E
a7]

-- | 
-- A stereo variable delay opcode with high quality interpolation.
--
-- > aout1, aout2  vdelayxs  ain1, ain2, adl, imd, iws [, ist]
--
-- csound doc: <http://csound.com/docs/manual/vdelayxs.html>
vdelayxs ::  Sig -> Sig -> Sig -> D -> D -> (Sig,Sig)
vdelayxs :: Sig -> Sig -> Sig -> D -> D -> (Sig, Sig)
vdelayxs Sig
b1 Sig
b2 Sig
b3 D
b4 D
b5 = GE (MultiOut [E]) -> (Sig, Sig)
forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple (GE (MultiOut [E]) -> (Sig, Sig))
-> GE (MultiOut [E]) -> (Sig, Sig)
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E -> MultiOut [E]
f (E -> E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> E -> MultiOut [E])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> E -> MultiOut [E]) -> GE E -> GE (E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b4 GE (E -> MultiOut [E]) -> GE E -> GE (MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b5
    where f :: E -> E -> E -> E -> E -> MultiOut [E]
f E
a1 E
a2 E
a3 E
a4 E
a5 = Name -> Specs -> [E] -> MultiOut [E]
mopcs Name
"vdelayxs" ([Rate
Ar,Rate
Ar],[Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ir,Rate
Ir,Rate
Ir]) [E
a1,E
a2,E
a3,E
a4,E
a5]

-- | 
-- Variable delay opcodes with high quality interpolation.
--
-- > aout  vdelayxw  ain, adl, imd, iws [, ist]
--
-- csound doc: <http://csound.com/docs/manual/vdelayxw.html>
vdelayxw ::  Sig -> Sig -> D -> D -> Sig
vdelayxw :: Sig -> Sig -> D -> D -> Sig
vdelayxw Sig
b1 Sig
b2 D
b3 D
b4 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E
f (E -> E -> E -> E -> E) -> GE E -> GE (E -> E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b3 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b4
    where f :: E -> E -> E -> E -> E
f E
a1 E
a2 E
a3 E
a4 = Name -> Spec1 -> [E] -> E
opcs Name
"vdelayxw" [(Rate
Ar,[Rate
Ar,Rate
Ar,Rate
Ir,Rate
Ir,Rate
Ir])] [E
a1,E
a2,E
a3,E
a4]

-- | 
-- Variable delay opcodes with high quality interpolation.
--
-- > aout1, aout2, aout3, aout4  vdelayxwq  ain1, ain2, ain3, ain4, adl, \
-- >           imd, iws [, ist]
--
-- csound doc: <http://csound.com/docs/manual/vdelayxwq.html>
vdelayxwq ::  Sig -> Sig -> Sig -> Sig -> Sig -> D -> D -> (Sig,Sig,Sig,Sig)
vdelayxwq :: Sig -> Sig -> Sig -> Sig -> Sig -> D -> D -> (Sig, Sig, Sig, Sig)
vdelayxwq Sig
b1 Sig
b2 Sig
b3 Sig
b4 Sig
b5 D
b6 D
b7 = GE (MultiOut [E]) -> (Sig, Sig, Sig, Sig)
forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple (GE (MultiOut [E]) -> (Sig, Sig, Sig, Sig))
-> GE (MultiOut [E]) -> (Sig, Sig, Sig, Sig)
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E -> E -> E -> MultiOut [E]
f (E -> E -> E -> E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> E -> E -> E -> MultiOut [E])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b4 GE (E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b5 GE (E -> E -> MultiOut [E]) -> GE E -> GE (E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b6 GE (E -> MultiOut [E]) -> GE E -> GE (MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b7
    where f :: E -> E -> E -> E -> E -> E -> E -> MultiOut [E]
f E
a1 E
a2 E
a3 E
a4 E
a5 E
a6 E
a7 = Name -> Specs -> [E] -> MultiOut [E]
mopcs Name
"vdelayxwq" ([Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar],[Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ir,Rate
Ir,Rate
Ir]) [E
a1
                                                                                               ,E
a2
                                                                                               ,E
a3
                                                                                               ,E
a4
                                                                                               ,E
a5
                                                                                               ,E
a6
                                                                                               ,E
a7]

-- | 
-- Variable delay opcodes with high quality interpolation.
--
-- > aout1, aout2  vdelayxws  ain1, ain2, adl, imd, iws [, ist]
--
-- csound doc: <http://csound.com/docs/manual/vdelayxws.html>
vdelayxws ::  Sig -> Sig -> Sig -> D -> D -> (Sig,Sig)
vdelayxws :: Sig -> Sig -> Sig -> D -> D -> (Sig, Sig)
vdelayxws Sig
b1 Sig
b2 Sig
b3 D
b4 D
b5 = GE (MultiOut [E]) -> (Sig, Sig)
forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple (GE (MultiOut [E]) -> (Sig, Sig))
-> GE (MultiOut [E]) -> (Sig, Sig)
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E -> MultiOut [E]
f (E -> E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> E -> MultiOut [E])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> E -> MultiOut [E]) -> GE E -> GE (E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b4 GE (E -> MultiOut [E]) -> GE E -> GE (MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b5
    where f :: E -> E -> E -> E -> E -> MultiOut [E]
f E
a1 E
a2 E
a3 E
a4 E
a5 = Name -> Specs -> [E] -> MultiOut [E]
mopcs Name
"vdelayxws" ([Rate
Ar,Rate
Ar],[Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ir,Rate
Ir,Rate
Ir]) [E
a1,E
a2,E
a3,E
a4,E
a5]

-- Panning and Spatialization.

-- | 
-- Deprecated. Decodes an ambisonic B format signal.
--
-- Decodes an ambisonic B format signal into loudspeaker specific signals. Note that this opcode is
--       deprecated as it is inaccurate, and is replaced by the much
--       better opcode bformdec1 which replicates all
--       the important features.
--
-- > ao1, ao2  bformdec  isetup, aw, ax, ay, az [, ar, as, at, au, av \
-- >           [, abk, al, am, an, ao, ap, aq]]
-- > ao1, ao2, ao3, ao4  bformdec  isetup, aw, ax, ay, az [, ar, as, at, \
-- >           au, av [, abk, al, am, an, ao, ap, aq]]
-- > ao1, ao2, ao3, ao4, ao5  bformdec  isetup, aw, ax, ay, az [, ar, as, \
-- >           at, au, av [, abk, al, am, an, ao, ap, aq]]
-- > ao1, ao2, ao3, ao4, ao5, ao6, ao7, ao8  bformdec  isetup, aw, ax, ay, az \
-- >           [, ar, as, at, au, av [, abk, al, am, an, ao, ap, aq]]]
--
-- csound doc: <http://csound.com/docs/manual/bformdec.html>
bformdec :: Tuple a => D -> Sig -> Sig -> Sig -> Sig -> a
bformdec :: forall a. Tuple a => D -> Sig -> Sig -> Sig -> Sig -> a
bformdec D
b1 Sig
b2 Sig
b3 Sig
b4 Sig
b5 = GE (MultiOut [E]) -> a
forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple (GE (MultiOut [E]) -> a) -> GE (MultiOut [E]) -> a
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E -> MultiOut [E]
f (E -> E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> E -> MultiOut [E])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> D -> GE E
unD D
b1 GE (E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> E -> MultiOut [E]) -> GE E -> GE (E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b4 GE (E -> MultiOut [E]) -> GE E -> GE (MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b5
    where f :: E -> E -> E -> E -> E -> MultiOut [E]
f E
a1 E
a2 E
a3 E
a4 E
a5 = Name -> Specs -> [E] -> MultiOut [E]
mopcs Name
"bformdec" ([Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar]
                                              ,[Rate
Ir,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar]) [E
a1,E
a2,E
a3,E
a4,E
a5]

-- | 
-- Decodes an ambisonic B format signal
--
-- Decodes an ambisonic B format signal into loudspeaker specific signals.
--
-- > ao1, ao2  bformdec1  isetup, aw, ax, ay, az [, ar, as, at, au, av \
-- >           [, abk, al, am, an, ao, ap, aq]]
-- > ao1, ao2, ao3, ao4  bformdec1  isetup, aw, ax, ay, az [, ar, as, at, \
-- >           au, av [, abk, al, am, an, ao, ap, aq]]
-- > ao1, ao2, ao3, ao4, ao5  bformdec1  isetup, aw, ax, ay, az [, ar, as, \
-- >           at, au, av [, abk, al, am, an, ao, ap, aq]]
-- > ao1, ao2, ao3, ao4, ao5, ao6, ao7, ao8  bformdec1  isetup, aw, ax, ay, az \
-- >           [, ar, as, at, au, av [, abk, al, am, an, ao, ap,
-- >         aq]]]
-- > aout[]  bformdec1  isetup, abform[]
--
-- csound doc: <http://csound.com/docs/manual/bformdec1.html>
bformdec1 :: Tuple a => D -> Sig -> Sig -> Sig -> Sig -> a
bformdec1 :: forall a. Tuple a => D -> Sig -> Sig -> Sig -> Sig -> a
bformdec1 D
b1 Sig
b2 Sig
b3 Sig
b4 Sig
b5 = GE (MultiOut [E]) -> a
forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple (GE (MultiOut [E]) -> a) -> GE (MultiOut [E]) -> a
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E -> MultiOut [E]
f (E -> E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> E -> MultiOut [E])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> D -> GE E
unD D
b1 GE (E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> E -> MultiOut [E]) -> GE E -> GE (E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b4 GE (E -> MultiOut [E]) -> GE E -> GE (MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b5
    where f :: E -> E -> E -> E -> E -> MultiOut [E]
f E
a1 E
a2 E
a3 E
a4 E
a5 = Name -> Specs -> [E] -> MultiOut [E]
mopcs Name
"bformdec1" ([Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar]
                                               ,[Rate
Ir,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar]) [E
a1,E
a2,E
a3,E
a4,E
a5]

-- | 
-- Deprecated. Codes a signal into the ambisonic B format.
--
-- Codes a signal into the ambisonic B format. Note that this opcode is
--       deprecated as it is inaccurate, and is replaced by the much
--       better
--       opcode bformenc1
--       which replicates all the important features; also note that the
--       gain arguments are not available in bformenc1.
--
-- > aw, ax, ay, az  bformenc  asig, kalpha, kbeta, kord0, kord1
-- > aw, ax, ay, az, ar, as, at, au, av  bformenc  asig, kalpha, kbeta, \
-- >           kord0, kord1 , kord2
-- > aw, ax, ay, az, ar, as, at, au, av, ak, al, am, an, ao, ap, aq  bformenc  \
-- >           asig, kalpha, kbeta, kord0, kord1, kord2, kord3
--
-- csound doc: <http://csound.com/docs/manual/bformenc.html>
bformenc :: Tuple a => Sig -> Sig -> Sig -> Sig -> Sig -> a
bformenc :: forall a. Tuple a => Sig -> Sig -> Sig -> Sig -> Sig -> a
bformenc Sig
b1 Sig
b2 Sig
b3 Sig
b4 Sig
b5 = GE (MultiOut [E]) -> a
forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple (GE (MultiOut [E]) -> a) -> GE (MultiOut [E]) -> a
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E -> MultiOut [E]
f (E -> E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> E -> MultiOut [E])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> E -> MultiOut [E]) -> GE E -> GE (E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b4 GE (E -> MultiOut [E]) -> GE E -> GE (MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b5
    where f :: E -> E -> E -> E -> E -> MultiOut [E]
f E
a1 E
a2 E
a3 E
a4 E
a5 = Name -> Specs -> [E] -> MultiOut [E]
mopcs Name
"bformenc" ([Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar]
                                              ,[Rate
Ar,Rate
Kr,Rate
Kr,Rate
Kr,Rate
Kr,Rate
Kr,Rate
Kr]) [E
a1,E
a2,E
a3,E
a4,E
a5]

-- | 
-- Codes a signal into the ambisonic B format.
--
-- Codes a signal into the ambisonic B format
--
-- > aw, ax, ay, az  bformenc1  asig, kalpha, kbeta
-- > aw, ax, ay, az, ar, as, at, au, av  bformenc1  asig, kalpha, kbeta
-- > aw, ax, ay, az, ar, as, at, au, av, ak, al, am, an, ao, ap, aq  bformenc1  \
-- >           asig, kalpha, kbeta
-- > aarray[]  bformenc1  asig, kalpha, kbeta
--
-- csound doc: <http://csound.com/docs/manual/bformenc1.html>
bformenc1 :: Tuple a => Sig -> Sig -> Sig -> a
bformenc1 :: forall a. Tuple a => Sig -> Sig -> Sig -> a
bformenc1 Sig
b1 Sig
b2 Sig
b3 = GE (MultiOut [E]) -> a
forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple (GE (MultiOut [E]) -> a) -> GE (MultiOut [E]) -> a
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> MultiOut [E]
f (E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> MultiOut [E])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> MultiOut [E]) -> GE E -> GE (E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> MultiOut [E]) -> GE E -> GE (MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> MultiOut [E]
f E
a1 E
a2 E
a3 = Name -> Specs -> [E] -> MultiOut [E]
mopcs Name
"bformenc1" ([Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar]
                                         ,[Rate
Ar,Rate
Kr,Rate
Kr]) [E
a1,E
a2,E
a3]

-- | 
-- Generates 3D binaural audio with high-fidelity early reflections in a parametric room using a Phase Truncation algorithm.
--
-- This opcode essentially nests the hrtfmove opcode in an image model for a user-definable shoebox-shaped room. A default room can be selected, or advanced room parameters can be used. Room surfaces can be controlled with high and low-frequency absorption coefficients and gain factors of a three-band equaliser.
--
-- > aleft, aright, irt60low, irt60high, imfp  hrtfearly  asrc, ksrcx, ksrcy, ksrcz, klstnrx, klstnry, klstnrz, \
-- >           ifilel, ifiler, idefroom [,ifade, isr, iorder, ithreed, kheadrot, iroomx, iroomy, iroomz, iwallhigh, \
-- >           iwalllow, iwallgain1, iwallgain2, iwallgain3, ifloorhigh, ifloorlow, ifloorgain1, ifloorgain2, \
-- >           ifloorgain3, iceilinghigh, iceilinglow, iceilinggain1, iceilinggain2, iceilinggain3]
--
-- csound doc: <http://csound.com/docs/manual/hrtfearly.html>
hrtfearly :: Tuple a => Sig -> Sig -> Sig -> Sig -> Sig -> Sig -> Sig -> D -> D -> D -> a
hrtfearly :: forall a.
Tuple a =>
Sig -> Sig -> Sig -> Sig -> Sig -> Sig -> Sig -> D -> D -> D -> a
hrtfearly Sig
b1 Sig
b2 Sig
b3 Sig
b4 Sig
b5 Sig
b6 Sig
b7 D
b8 D
b9 D
b10 = GE (MultiOut [E]) -> a
forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple (GE (MultiOut [E]) -> a) -> GE (MultiOut [E]) -> a
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E -> E -> E -> E -> E -> E -> MultiOut [E]
f (E -> E -> E -> E -> E -> E -> E -> E -> E -> E -> MultiOut [E])
-> GE E
-> GE (E -> E -> E -> E -> E -> E -> E -> E -> E -> MultiOut [E])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E -> E -> E -> E -> E -> E -> MultiOut [E])
-> GE E
-> GE (E -> E -> E -> E -> E -> E -> E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> E -> E -> E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> E -> E -> E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> E -> E -> E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> E -> E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b4 GE (E -> E -> E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b5 GE (E -> E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b6 GE (E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b7 GE (E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b8 GE (E -> E -> MultiOut [E]) -> GE E -> GE (E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b9 GE (E -> MultiOut [E]) -> GE E -> GE (MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b10
    where f :: E -> E -> E -> E -> E -> E -> E -> E -> E -> E -> MultiOut [E]
f E
a1 E
a2 E
a3 E
a4 E
a5 E
a6 E
a7 E
a8 E
a9 E
a10 = Name -> Specs -> [E] -> MultiOut [E]
mopcs Name
"hrtfearly" ([Rate
Ar,Rate
Ar,Rate
Ir,Rate
Ir,Rate
Ir]
                                                               ,[Rate
Ar
                                                                ,Rate
Kr
                                                                ,Rate
Kr
                                                                ,Rate
Kr
                                                                ,Rate
Kr
                                                                ,Rate
Kr
                                                                ,Rate
Kr
                                                                ,Rate
Ir
                                                                ,Rate
Ir
                                                                ,Rate
Ir
                                                                ,Rate
Ir
                                                                ,Rate
Ir
                                                                ,Rate
Ir
                                                                ,Rate
Ir
                                                                ,Rate
Kr
                                                                ,Rate
Ir
                                                                ,Rate
Ir
                                                                ,Rate
Ir
                                                                ,Rate
Ir
                                                                ,Rate
Ir
                                                                ,Rate
Ir
                                                                ,Rate
Ir
                                                                ,Rate
Ir
                                                                ,Rate
Ir
                                                                ,Rate
Ir
                                                                ,Rate
Ir
                                                                ,Rate
Ir
                                                                ,Rate
Ir
                                                                ,Rate
Ir
                                                                ,Rate
Ir
                                                                ,Rate
Ir
                                                                ,Rate
Ir
                                                                ,Rate
Ir]) [E
a1,E
a2,E
a3,E
a4,E
a5,E
a6,E
a7,E
a8,E
a9,E
a10]

-- | 
-- Generates dynamic 3d binaural audio for headphones using magnitude interpolation and phase truncation.
--
-- This opcode takes a source signal and spatialises it in the 3 dimensional space around a listener
--       by convolving the source with stored head related transfer function (HRTF) based filters.
--
-- > aleft, aright  hrtfmove  asrc, kAz, kElev, ifilel, ifiler [, imode, ifade, isr]
--
-- csound doc: <http://csound.com/docs/manual/hrtfmove.html>
hrtfmove ::  Sig -> Sig -> Sig -> D -> D -> (Sig,Sig)
hrtfmove :: Sig -> Sig -> Sig -> D -> D -> (Sig, Sig)
hrtfmove Sig
b1 Sig
b2 Sig
b3 D
b4 D
b5 = GE (MultiOut [E]) -> (Sig, Sig)
forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple (GE (MultiOut [E]) -> (Sig, Sig))
-> GE (MultiOut [E]) -> (Sig, Sig)
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E -> MultiOut [E]
f (E -> E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> E -> MultiOut [E])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> E -> MultiOut [E]) -> GE E -> GE (E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b4 GE (E -> MultiOut [E]) -> GE E -> GE (MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b5
    where f :: E -> E -> E -> E -> E -> MultiOut [E]
f E
a1 E
a2 E
a3 E
a4 E
a5 = Name -> Specs -> [E] -> MultiOut [E]
mopcs Name
"hrtfmove" ([Rate
Ar,Rate
Ar],[Rate
Ar,Rate
Kr,Rate
Kr,Rate
Ir,Rate
Ir,Rate
Ir,Rate
Ir,Rate
Ir]) [E
a1,E
a2,E
a3,E
a4,E
a5]

-- | 
-- Generates dynamic 3d binaural audio for headphones using a Woodworth based spherical head model
--       with improved low frequency phase accuracy.
--
-- This opcode takes a source signal and spatialises it in the 3 dimensional space around a listener
--       using head related transfer function (HRTF) based filters.
--
-- > aleft, aright  hrtfmove2  asrc, kAz, kElev, ifilel, ifiler [,ioverlap, iradius, isr]
--
-- csound doc: <http://csound.com/docs/manual/hrtfmove2.html>
hrtfmove2 ::  Sig -> Sig -> Sig -> D -> D -> (Sig,Sig)
hrtfmove2 :: Sig -> Sig -> Sig -> D -> D -> (Sig, Sig)
hrtfmove2 Sig
b1 Sig
b2 Sig
b3 D
b4 D
b5 = GE (MultiOut [E]) -> (Sig, Sig)
forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple (GE (MultiOut [E]) -> (Sig, Sig))
-> GE (MultiOut [E]) -> (Sig, Sig)
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E -> MultiOut [E]
f (E -> E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> E -> MultiOut [E])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> E -> MultiOut [E]) -> GE E -> GE (E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b4 GE (E -> MultiOut [E]) -> GE E -> GE (MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b5
    where f :: E -> E -> E -> E -> E -> MultiOut [E]
f E
a1 E
a2 E
a3 E
a4 E
a5 = Name -> Specs -> [E] -> MultiOut [E]
mopcs Name
"hrtfmove2" ([Rate
Ar,Rate
Ar],[Rate
Ar,Rate
Kr,Rate
Kr,Rate
Ir,Rate
Ir,Rate
Ir,Rate
Ir,Rate
Ir]) [E
a1,E
a2,E
a3,E
a4,E
a5]

-- | 
-- A binaural, dynamic FDN based diffuse-field reverberator. The opcode works independently as an efficient, flexible reverberator.
--
-- A frequency-dependent, efficient reverberant field is created based on low and high frequency desired reverb times. The opcode is designed to work with hrtfearly, ideally using its outputs as inputs. However, hrtfreverb can be used as a standalone tool. Stability is enforced.
--
-- > aleft, aright, idel  hrtfreverb  asrc, ilowrt60, ihighrt60, ifilel, ifiler [,isr, imfp, iorder]
--
-- csound doc: <http://csound.com/docs/manual/hrtfreverb.html>
hrtfreverb ::  Sig -> D -> D -> D -> D -> (Sig,Sig,D)
hrtfreverb :: Sig -> D -> D -> D -> D -> (Sig, Sig, D)
hrtfreverb Sig
b1 D
b2 D
b3 D
b4 D
b5 = GE (MultiOut [E]) -> (Sig, Sig, D)
forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple (GE (MultiOut [E]) -> (Sig, Sig, D))
-> GE (MultiOut [E]) -> (Sig, Sig, D)
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E -> MultiOut [E]
f (E -> E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> E -> MultiOut [E])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b2 GE (E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b3 GE (E -> E -> MultiOut [E]) -> GE E -> GE (E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b4 GE (E -> MultiOut [E]) -> GE E -> GE (MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b5
    where f :: E -> E -> E -> E -> E -> MultiOut [E]
f E
a1 E
a2 E
a3 E
a4 E
a5 = Name -> Specs -> [E] -> MultiOut [E]
mopcs Name
"hrtfreverb" ([Rate
Ar,Rate
Ar,Rate
Ir],[Rate
Ar,Rate
Ir,Rate
Ir,Rate
Ir,Rate
Ir,Rate
Ir,Rate
Ir,Rate
Ir]) [E
a1
                                                                                       ,E
a2
                                                                                       ,E
a3
                                                                                       ,E
a4
                                                                                       ,E
a5]

-- | 
-- Generates static 3d binaural audio for headphones using a
--       Woodworth based spherical head model with improved low frequency
--       phase accuracy.
--
-- This opcode takes a source signal and spatialises it in the 3 dimensional space around a listener using head related transfer function (HRTF) based filters. It produces a static output (azimuth and elevation parameters are i-rate), because a static source allows much more efficient processing than hrtfmove and hrtfmove2,.
--
-- >       aleft, aright  hrtfstat  asrc, iAz, iElev, ifilel, ifiler [,iradius, isr]
-- >         
--
-- csound doc: <http://csound.com/docs/manual/hrtfstat.html>
hrtfstat ::  Sig -> D -> D -> D -> D -> (Sig,Sig)
hrtfstat :: Sig -> D -> D -> D -> D -> (Sig, Sig)
hrtfstat Sig
b1 D
b2 D
b3 D
b4 D
b5 = GE (MultiOut [E]) -> (Sig, Sig)
forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple (GE (MultiOut [E]) -> (Sig, Sig))
-> GE (MultiOut [E]) -> (Sig, Sig)
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E -> MultiOut [E]
f (E -> E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> E -> MultiOut [E])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b2 GE (E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b3 GE (E -> E -> MultiOut [E]) -> GE E -> GE (E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b4 GE (E -> MultiOut [E]) -> GE E -> GE (MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b5
    where f :: E -> E -> E -> E -> E -> MultiOut [E]
f E
a1 E
a2 E
a3 E
a4 E
a5 = Name -> Specs -> [E] -> MultiOut [E]
mopcs Name
"hrtfstat" ([Rate
Ar,Rate
Ar],[Rate
Ar,Rate
Ir,Rate
Ir,Rate
Ir,Rate
Ir,Rate
Ir,Rate
Ir]) [E
a1,E
a2,E
a3,E
a4,E
a5]

-- | 
-- Distributes the audio signals of a previous locsig opcode.
--
-- locsend depends upon the existence of a previously defined locsig. The number of output signals must match the number in the previous locsig. The output signals from locsend are derived from the values given for distance and reverb in the locsig and are ready to be sent to local or global reverb units (see example below). The reverb amount and the balance between the 2 or 4 channels are calculated in the same way as described in the Dodge book (an essential text!).
--
-- > a1, a2  locsend 
-- > a1, a2,  a3, a4  locsend 
--
-- csound doc: <http://csound.com/docs/manual/locsend.html>
locsend ::   (Sig,Sig,Sig,Sig)
locsend :: (Sig, Sig, Sig, Sig)
locsend  = GE (MultiOut [E]) -> (Sig, Sig, Sig, Sig)
forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple (GE (MultiOut [E]) -> (Sig, Sig, Sig, Sig))
-> GE (MultiOut [E]) -> (Sig, Sig, Sig, Sig)
forall a b. (a -> b) -> a -> b
$ MultiOut [E] -> GE (MultiOut [E])
forall a. a -> GE a
forall (m :: * -> *) a. Monad m => a -> m a
return (MultiOut [E] -> GE (MultiOut [E]))
-> MultiOut [E] -> GE (MultiOut [E])
forall a b. (a -> b) -> a -> b
$ MultiOut [E]
f 
    where f :: MultiOut [E]
f  = Name -> Specs -> [E] -> MultiOut [E]
mopcs Name
"locsend" ([Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar],[]) []

-- | 
-- Takes an input signal and distributes between 2 or 4 channels.
--
-- locsig takes an input signal and distributes it among 2 or 4 channels using values in degrees to calculate the balance between adjacent channels. It also takes arguments for distance (used to attenuate signals that are to sound as if they are some distance further than the loudspeaker itself), and for the amount the signal that will be sent to reverberators. This unit is based upon the example in the Charles Dodge/Thomas Jerse book, Computer Music, page 320.
--
-- > a1, a2  locsig  asig, kdegree, kdistance, kreverbsend
-- > a1, a2,  a3, a4  locsig  asig, kdegree, kdistance, kreverbsend
--
-- csound doc: <http://csound.com/docs/manual/locsig.html>
locsig ::  Sig -> Sig -> Sig -> Sig -> (Sig,Sig,Sig,Sig)
locsig :: Sig -> Sig -> Sig -> Sig -> (Sig, Sig, Sig, Sig)
locsig Sig
b1 Sig
b2 Sig
b3 Sig
b4 = GE (MultiOut [E]) -> (Sig, Sig, Sig, Sig)
forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple (GE (MultiOut [E]) -> (Sig, Sig, Sig, Sig))
-> GE (MultiOut [E]) -> (Sig, Sig, Sig, Sig)
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> MultiOut [E]
f (E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> MultiOut [E])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> MultiOut [E]) -> GE E -> GE (E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> MultiOut [E]) -> GE E -> GE (MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b4
    where f :: E -> E -> E -> E -> MultiOut [E]
f E
a1 E
a2 E
a3 E
a4 = Name -> Specs -> [E] -> MultiOut [E]
mopcs Name
"locsig" ([Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar],[Rate
Ar,Rate
Kr,Rate
Kr,Rate
Kr]) [E
a1,E
a2,E
a3,E
a4]

-- | 
-- Distribute an audio signal amongst four channels.
--
-- Distribute an audio signal amongst four channels with localization control.
--
-- > a1, a2, a3, a4  pan  asig, kx, ky, ifn [, imode] [, ioffset]
--
-- csound doc: <http://csound.com/docs/manual/pan.html>
pan ::  Sig -> Sig -> Sig -> Tab -> (Sig,Sig,Sig,Sig)
pan :: Sig -> Sig -> Sig -> Tab -> (Sig, Sig, Sig, Sig)
pan Sig
b1 Sig
b2 Sig
b3 Tab
b4 = GE (MultiOut [E]) -> (Sig, Sig, Sig, Sig)
forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple (GE (MultiOut [E]) -> (Sig, Sig, Sig, Sig))
-> GE (MultiOut [E]) -> (Sig, Sig, Sig, Sig)
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> MultiOut [E]
f (E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> MultiOut [E])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> MultiOut [E]) -> GE E -> GE (E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> MultiOut [E]) -> GE E -> GE (MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Tab -> GE E
unTab Tab
b4
    where f :: E -> E -> E -> E -> MultiOut [E]
f E
a1 E
a2 E
a3 E
a4 = Name -> Specs -> [E] -> MultiOut [E]
mopcs Name
"pan" ([Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar],[Rate
Ar,Rate
Kr,Rate
Kr,Rate
Ir,Rate
Ir,Rate
Ir]) [E
a1,E
a2,E
a3,E
a4]

-- | 
-- Distribute an audio signal across two channels.
--
-- Distribute an audio signal across two channels with a choice of methods.
--
-- > a1, a2  pan2  asig, xp [, imode]
--
-- csound doc: <http://csound.com/docs/manual/pan2.html>
pan2 ::  Sig -> Sig -> (Sig,Sig)
pan2 :: Sig -> Sig -> (Sig, Sig)
pan2 Sig
b1 Sig
b2 = GE (MultiOut [E]) -> (Sig, Sig)
forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple (GE (MultiOut [E]) -> (Sig, Sig))
-> GE (MultiOut [E]) -> (Sig, Sig)
forall a b. (a -> b) -> a -> b
$ E -> E -> MultiOut [E]
f (E -> E -> MultiOut [E]) -> GE E -> GE (E -> MultiOut [E])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> MultiOut [E]) -> GE E -> GE (MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2
    where f :: E -> E -> MultiOut [E]
f E
a1 E
a2 = Name -> Specs -> [E] -> MultiOut [E]
mopcs Name
"pan2" ([Rate
Ar,Rate
Ar],[Rate
Ar,Rate
Xr,Rate
Ir]) [E
a1,E
a2]

-- | 
-- Distributes an input signal among 4 channels using cartesian coordinates.
--
-- space takes an input signal and distributes it among 4 channels using Cartesian xy coordinates to calculate the balance of the outputs. The xy coordinates can be defined in a separate text file and accessed through a Function statement in the score using Gen28, or they can be specified using the optional kx, ky arguments. The advantages to the former are:
--
-- > a1, a2, a3, a4   space  asig, ifn, ktime, kreverbsend, kx, ky
--
-- csound doc: <http://csound.com/docs/manual/space.html>
space ::  Sig -> Tab -> Sig -> Sig -> Sig -> Sig -> (Sig,Sig,Sig,Sig)
space :: Sig -> Tab -> Sig -> Sig -> Sig -> Sig -> (Sig, Sig, Sig, Sig)
space Sig
b1 Tab
b2 Sig
b3 Sig
b4 Sig
b5 Sig
b6 = GE (MultiOut [E]) -> (Sig, Sig, Sig, Sig)
forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple (GE (MultiOut [E]) -> (Sig, Sig, Sig, Sig))
-> GE (MultiOut [E]) -> (Sig, Sig, Sig, Sig)
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E -> E -> MultiOut [E]
f (E -> E -> E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> E -> E -> MultiOut [E])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Tab -> GE E
unTab Tab
b2 GE (E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b4 GE (E -> E -> MultiOut [E]) -> GE E -> GE (E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b5 GE (E -> MultiOut [E]) -> GE E -> GE (MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b6
    where f :: E -> E -> E -> E -> E -> E -> MultiOut [E]
f E
a1 E
a2 E
a3 E
a4 E
a5 E
a6 = Name -> Specs -> [E] -> MultiOut [E]
mopcs Name
"space" ([Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar],[Rate
Ar,Rate
Ir,Rate
Kr,Rate
Kr,Rate
Kr,Rate
Kr]) [E
a1
                                                                                  ,E
a2
                                                                                  ,E
a3
                                                                                  ,E
a4
                                                                                  ,E
a5
                                                                                  ,E
a6]

-- | 
-- Positions the input sound in a 3D space and allows moving the sound at k-rate.
--
-- This opcode positions the input sound in a 3D space, with optional simulation of room acoustics, in various output formats. spat3d allows moving the sound at k-rate (this movement is interpolated internally to eliminate "zipper noise" if sr not equal to kr).
--
-- > aW, aX, aY, aZ  spat3d  ain, kX, kY, kZ, idist, ift, imode, imdel, iovr [, istor]
--
-- csound doc: <http://csound.com/docs/manual/spat3d.html>
spat3d ::  Sig -> Sig -> Sig -> Sig -> D -> D -> D -> D -> D -> (Sig,Sig,Sig,Sig)
spat3d :: Sig
-> Sig
-> Sig
-> Sig
-> D
-> D
-> D
-> D
-> D
-> (Sig, Sig, Sig, Sig)
spat3d Sig
b1 Sig
b2 Sig
b3 Sig
b4 D
b5 D
b6 D
b7 D
b8 D
b9 = GE (MultiOut [E]) -> (Sig, Sig, Sig, Sig)
forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple (GE (MultiOut [E]) -> (Sig, Sig, Sig, Sig))
-> GE (MultiOut [E]) -> (Sig, Sig, Sig, Sig)
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E -> E -> E -> E -> E -> MultiOut [E]
f (E -> E -> E -> E -> E -> E -> E -> E -> E -> MultiOut [E])
-> GE E
-> GE (E -> E -> E -> E -> E -> E -> E -> E -> MultiOut [E])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E -> E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> E -> E -> E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> E -> E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> E -> E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> E -> E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b4 GE (E -> E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b5 GE (E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b6 GE (E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b7 GE (E -> E -> MultiOut [E]) -> GE E -> GE (E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b8 GE (E -> MultiOut [E]) -> GE E -> GE (MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b9
    where f :: E -> E -> E -> E -> E -> E -> E -> E -> E -> MultiOut [E]
f E
a1 E
a2 E
a3 E
a4 E
a5 E
a6 E
a7 E
a8 E
a9 = Name -> Specs -> [E] -> MultiOut [E]
mopcs Name
"spat3d" ([Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar]
                                                        ,[Rate
Ar,Rate
Kr,Rate
Kr,Rate
Kr,Rate
Ir,Rate
Ir,Rate
Ir,Rate
Ir,Rate
Ir,Rate
Ir]) [E
a1,E
a2,E
a3,E
a4,E
a5,E
a6,E
a7,E
a8,E
a9]

-- | 
-- Positions the input sound in a 3D space with the sound source position set at i-time.
--
-- This opcode positions the input sound in a 3D space, with optional simulation of room acoustics, in various output formats. With spat3di, sound source position is set at i-time.
--
-- > aW, aX, aY, aZ  spat3di  ain, iX, iY, iZ, idist, ift, imode [, istor]
--
-- csound doc: <http://csound.com/docs/manual/spat3di.html>
spat3di ::  Sig -> D -> D -> D -> D -> D -> D -> (Sig,Sig,Sig,Sig)
spat3di :: Sig -> D -> D -> D -> D -> D -> D -> (Sig, Sig, Sig, Sig)
spat3di Sig
b1 D
b2 D
b3 D
b4 D
b5 D
b6 D
b7 = GE (MultiOut [E]) -> (Sig, Sig, Sig, Sig)
forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple (GE (MultiOut [E]) -> (Sig, Sig, Sig, Sig))
-> GE (MultiOut [E]) -> (Sig, Sig, Sig, Sig)
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E -> E -> E -> MultiOut [E]
f (E -> E -> E -> E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> E -> E -> E -> MultiOut [E])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b2 GE (E -> E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b3 GE (E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b4 GE (E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b5 GE (E -> E -> MultiOut [E]) -> GE E -> GE (E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b6 GE (E -> MultiOut [E]) -> GE E -> GE (MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b7
    where f :: E -> E -> E -> E -> E -> E -> E -> MultiOut [E]
f E
a1 E
a2 E
a3 E
a4 E
a5 E
a6 E
a7 = Name -> Specs -> [E] -> MultiOut [E]
mopcs Name
"spat3di" ([Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar],[Rate
Ar,Rate
Ir,Rate
Ir,Rate
Ir,Rate
Ir,Rate
Ir,Rate
Ir,Rate
Ir]) [E
a1
                                                                                             ,E
a2
                                                                                             ,E
a3
                                                                                             ,E
a4
                                                                                             ,E
a5
                                                                                             ,E
a6
                                                                                             ,E
a7]

-- | 
-- Can be used to render an impulse response for a 3D space at i-time.
--
-- This opcode positions the input sound in a 3D space, with optional simulation of room acoustics, in various output formats. spat3dt can be used to render the impulse response at i-time, storing output in a function table, suitable for convolution.
--
-- >  spat3dt  ioutft, iX, iY, iZ, idist, ift, imode, irlen [, iftnocl]
--
-- csound doc: <http://csound.com/docs/manual/spat3dt.html>
spat3dt ::  D -> D -> D -> D -> D -> D -> D -> D -> SE ()
spat3dt :: D -> D -> D -> D -> D -> D -> D -> D -> SE ()
spat3dt D
b1 D
b2 D
b3 D
b4 D
b5 D
b6 D
b7 D
b8 = Dep () -> SE ()
forall a. Dep a -> SE a
SE (Dep () -> SE ()) -> Dep () -> SE ()
forall a b. (a -> b) -> a -> b
$ (E -> Dep ()
forall (m :: * -> *). Monad m => E -> DepT m ()
depT_ (E -> Dep ()) -> DepT GE E -> Dep ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<<) (DepT GE E -> Dep ()) -> DepT GE E -> Dep ()
forall a b. (a -> b) -> a -> b
$ GE E -> DepT GE E
forall (m :: * -> *) a. Monad m => m a -> DepT m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (GE E -> DepT GE E) -> GE E -> DepT GE E
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E -> E -> E -> E -> E
f (E -> E -> E -> E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E -> E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> D -> GE E
unD D
b1 GE (E -> E -> E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b2 GE (E -> E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b3 GE (E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b4 GE (E -> E -> E -> E -> E) -> GE E -> GE (E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b5 GE (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b6 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b7 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b8
    where f :: E -> E -> E -> E -> E -> E -> E -> E -> E
f E
a1 E
a2 E
a3 E
a4 E
a5 E
a6 E
a7 E
a8 = Name -> Spec1 -> [E] -> E
opcs Name
"spat3dt" [(Rate
Xr,[Rate
Ir,Rate
Ir,Rate
Ir,Rate
Ir,Rate
Ir,Rate
Ir,Rate
Ir,Rate
Ir,Rate
Ir])] [E
a1
                                                                                         ,E
a2
                                                                                         ,E
a3
                                                                                         ,E
a4
                                                                                         ,E
a5
                                                                                         ,E
a6
                                                                                         ,E
a7
                                                                                         ,E
a8]

-- | 
-- Calculates distance values from xy coordinates.
--
-- spdist uses the same xy data as space, also either from a text file using Gen28 or from x and y arguments given to the unit directly. The purpose of this unit is to make available the values for distance that are calculated from the xy coordinates.
--
-- > k1  spdist  ifn, ktime, kx, ky
--
-- csound doc: <http://csound.com/docs/manual/spdist.html>
spdist ::  Tab -> Sig -> Sig -> Sig -> Sig
spdist :: Tab -> Sig -> Sig -> Sig -> Sig
spdist Tab
b1 Sig
b2 Sig
b3 Sig
b4 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E
f (E -> E -> E -> E -> E) -> GE E -> GE (E -> E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Tab -> GE E
unTab Tab
b1 GE (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b4
    where f :: E -> E -> E -> E -> E
f E
a1 E
a2 E
a3 E
a4 = Name -> Spec1 -> [E] -> E
opcs Name
"spdist" [(Rate
Kr,[Rate
Ir,Rate
Kr,Rate
Kr,Rate
Kr])] [E
a1,E
a2,E
a3,E
a4]

-- | 
-- Generates output signals based on a previously defined space opcode.
--
-- spsend depends upon the existence of a previously defined space. The output signals from spsend are derived from the values given for xy and reverb in the space and are ready to be sent to local or global reverb units (see example below).
--
-- > a1, a2, a3, a4  spsend 
--
-- csound doc: <http://csound.com/docs/manual/spsend.html>
spsend ::   (Sig,Sig,Sig,Sig)
spsend :: (Sig, Sig, Sig, Sig)
spsend  = GE (MultiOut [E]) -> (Sig, Sig, Sig, Sig)
forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple (GE (MultiOut [E]) -> (Sig, Sig, Sig, Sig))
-> GE (MultiOut [E]) -> (Sig, Sig, Sig, Sig)
forall a b. (a -> b) -> a -> b
$ MultiOut [E] -> GE (MultiOut [E])
forall a. a -> GE a
forall (m :: * -> *) a. Monad m => a -> m a
return (MultiOut [E] -> GE (MultiOut [E]))
-> MultiOut [E] -> GE (MultiOut [E])
forall a b. (a -> b) -> a -> b
$ MultiOut [E]
f 
    where f :: MultiOut [E]
f  = Name -> Specs -> [E] -> MultiOut [E]
mopcs Name
"spsend" ([Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar],[]) []

-- | 
-- Distributes an audio signal among many channels.
--
-- Distributes an audio signal amongmany channels, up to 64 in the
--       first form, arbitrary in the second.
--
-- > ar1[, ar2...]  vbap  asig, kazim [,
-- >         kelev] [, kspread] [, ilayout]
-- > array[]  vbap  asig, kazim [,
-- >         kelev] [, kspread] [, ilayout]
--
-- csound doc: <http://csound.com/docs/manual/vbap.html>
vbap :: Tuple a => Sig -> Sig -> a
vbap :: forall a. Tuple a => Sig -> Sig -> a
vbap Sig
b1 Sig
b2 = GE (MultiOut [E]) -> a
forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple (GE (MultiOut [E]) -> a) -> GE (MultiOut [E]) -> a
forall a b. (a -> b) -> a -> b
$ E -> E -> MultiOut [E]
f (E -> E -> MultiOut [E]) -> GE E -> GE (E -> MultiOut [E])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> MultiOut [E]) -> GE E -> GE (MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2
    where f :: E -> E -> MultiOut [E]
f E
a1 E
a2 = Name -> Specs -> [E] -> MultiOut [E]
mopcs Name
"vbap" ((Rate -> [Rate]
forall a. a -> [a]
repeat Rate
Ar),[Rate
Ar,Rate
Kr,Rate
Kr,Rate
Kr,Rate
Ir]) [E
a1,E
a2]

-- | 
-- Distributes an audio signal among 16 channels.
--
-- > ar1, ..., ar16  vbap16  asig, kazim [, kelev] [, kspread]
--
-- csound doc: <http://csound.com/docs/manual/vbap16.html>
vbap16 :: Tuple a => Sig -> Sig -> a
vbap16 :: forall a. Tuple a => Sig -> Sig -> a
vbap16 Sig
b1 Sig
b2 = GE (MultiOut [E]) -> a
forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple (GE (MultiOut [E]) -> a) -> GE (MultiOut [E]) -> a
forall a b. (a -> b) -> a -> b
$ E -> E -> MultiOut [E]
f (E -> E -> MultiOut [E]) -> GE E -> GE (E -> MultiOut [E])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> MultiOut [E]) -> GE E -> GE (MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2
    where f :: E -> E -> MultiOut [E]
f E
a1 E
a2 = Name -> Specs -> [E] -> MultiOut [E]
mopcs Name
"vbap16" ((Rate -> [Rate]
forall a. a -> [a]
repeat Rate
Ar),[Rate
Ar,Rate
Kr,Rate
Kr,Rate
Kr]) [E
a1,E
a2]

-- | 
-- Distribute an audio signal among 16 channels with moving virtual sources.
--
-- > ar1, ..., ar16  vbap16move  asig, idur, ispread, ifldnum, ifld1 \
-- >           [, ifld2] [...]
--
-- csound doc: <http://csound.com/docs/manual/vbap16move.html>
vbap16move :: Tuple a => Sig -> D -> D -> D -> [D] -> a
vbap16move :: forall a. Tuple a => Sig -> D -> D -> D -> [D] -> a
vbap16move Sig
b1 D
b2 D
b3 D
b4 [D]
b5 = GE (MultiOut [E]) -> a
forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple (GE (MultiOut [E]) -> a) -> GE (MultiOut [E]) -> a
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> [E] -> MultiOut [E]
f (E -> E -> E -> E -> [E] -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> [E] -> MultiOut [E])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> [E] -> MultiOut [E])
-> GE E -> GE (E -> E -> [E] -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b2 GE (E -> E -> [E] -> MultiOut [E])
-> GE E -> GE (E -> [E] -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b3 GE (E -> [E] -> MultiOut [E]) -> GE E -> GE ([E] -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b4 GE ([E] -> MultiOut [E]) -> GE [E] -> GE (MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (D -> GE E) -> [D] -> GE [E]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM D -> GE E
unD [D]
b5
    where f :: E -> E -> E -> E -> [E] -> MultiOut [E]
f E
a1 E
a2 E
a3 E
a4 [E]
a5 = Name -> Specs -> [E] -> MultiOut [E]
mopcs Name
"vbap16move" ((Rate -> [Rate]
forall a. a -> [a]
repeat Rate
Ar),[Rate
Ar] [Rate] -> [Rate] -> [Rate]
forall a. [a] -> [a] -> [a]
++ (Rate -> [Rate]
forall a. a -> [a]
repeat Rate
Ir)) ([E
a1
                                                                                   ,E
a2
                                                                                   ,E
a3
                                                                                   ,E
a4] [E] -> [E] -> [E]
forall a. [a] -> [a] -> [a]
++ [E]
a5)

-- | 
-- Distributes an audio signal among 4 channels.
--
-- > ar1, ar2, ar3, ar4  vbap4  asig, kazim [, kelev] [, kspread]
--
-- csound doc: <http://csound.com/docs/manual/vbap4.html>
vbap4 ::  Sig -> Sig -> (Sig,Sig,Sig,Sig)
vbap4 :: Sig -> Sig -> (Sig, Sig, Sig, Sig)
vbap4 Sig
b1 Sig
b2 = GE (MultiOut [E]) -> (Sig, Sig, Sig, Sig)
forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple (GE (MultiOut [E]) -> (Sig, Sig, Sig, Sig))
-> GE (MultiOut [E]) -> (Sig, Sig, Sig, Sig)
forall a b. (a -> b) -> a -> b
$ E -> E -> MultiOut [E]
f (E -> E -> MultiOut [E]) -> GE E -> GE (E -> MultiOut [E])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> MultiOut [E]) -> GE E -> GE (MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2
    where f :: E -> E -> MultiOut [E]
f E
a1 E
a2 = Name -> Specs -> [E] -> MultiOut [E]
mopcs Name
"vbap4" ([Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar],[Rate
Ar,Rate
Kr,Rate
Kr,Rate
Kr]) [E
a1,E
a2]

-- | 
-- Distributes an audio signal among 4 channels with moving virtual sources.
--
-- > ar1, ar2, ar3, ar4  vbap4move  asig, idur, ispread, ifldnum, ifld1 \
-- >           [, ifld2] [...]
--
-- csound doc: <http://csound.com/docs/manual/vbap4move.html>
vbap4move :: Tuple a => Sig -> D -> D -> D -> [D] -> a
vbap4move :: forall a. Tuple a => Sig -> D -> D -> D -> [D] -> a
vbap4move Sig
b1 D
b2 D
b3 D
b4 [D]
b5 = GE (MultiOut [E]) -> a
forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple (GE (MultiOut [E]) -> a) -> GE (MultiOut [E]) -> a
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> [E] -> MultiOut [E]
f (E -> E -> E -> E -> [E] -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> [E] -> MultiOut [E])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> [E] -> MultiOut [E])
-> GE E -> GE (E -> E -> [E] -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b2 GE (E -> E -> [E] -> MultiOut [E])
-> GE E -> GE (E -> [E] -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b3 GE (E -> [E] -> MultiOut [E]) -> GE E -> GE ([E] -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b4 GE ([E] -> MultiOut [E]) -> GE [E] -> GE (MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (D -> GE E) -> [D] -> GE [E]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM D -> GE E
unD [D]
b5
    where f :: E -> E -> E -> E -> [E] -> MultiOut [E]
f E
a1 E
a2 E
a3 E
a4 [E]
a5 = Name -> Specs -> [E] -> MultiOut [E]
mopcs Name
"vbap4move" ([Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar],[Rate
Ar] [Rate] -> [Rate] -> [Rate]
forall a. [a] -> [a] -> [a]
++ (Rate -> [Rate]
forall a. a -> [a]
repeat Rate
Ir)) ([E
a1
                                                                                    ,E
a2
                                                                                    ,E
a3
                                                                                    ,E
a4] [E] -> [E] -> [E]
forall a. [a] -> [a] -> [a]
++ [E]
a5)

-- | 
-- Distributes an audio signal among 8 channels.
--
-- > ar1, ..., ar8  vbap8  asig, kazim [, kelev] [, kspread]
--
-- csound doc: <http://csound.com/docs/manual/vbap8.html>
vbap8 :: Tuple a => Sig -> Sig -> a
vbap8 :: forall a. Tuple a => Sig -> Sig -> a
vbap8 Sig
b1 Sig
b2 = GE (MultiOut [E]) -> a
forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple (GE (MultiOut [E]) -> a) -> GE (MultiOut [E]) -> a
forall a b. (a -> b) -> a -> b
$ E -> E -> MultiOut [E]
f (E -> E -> MultiOut [E]) -> GE E -> GE (E -> MultiOut [E])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> MultiOut [E]) -> GE E -> GE (MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2
    where f :: E -> E -> MultiOut [E]
f E
a1 E
a2 = Name -> Specs -> [E] -> MultiOut [E]
mopcs Name
"vbap8" ((Rate -> [Rate]
forall a. a -> [a]
repeat Rate
Ar),[Rate
Ar,Rate
Kr,Rate
Kr,Rate
Kr]) [E
a1,E
a2]

-- | 
-- Distributes an audio signal among 8 channels with moving virtual sources.
--
-- > ar1, ..., ar8  vbap8move  asig, idur, ispread, ifldnum, ifld1 \
-- >           [, ifld2] [...]
--
-- csound doc: <http://csound.com/docs/manual/vbap8move.html>
vbap8move :: Tuple a => Sig -> D -> D -> D -> [D] -> a
vbap8move :: forall a. Tuple a => Sig -> D -> D -> D -> [D] -> a
vbap8move Sig
b1 D
b2 D
b3 D
b4 [D]
b5 = GE (MultiOut [E]) -> a
forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple (GE (MultiOut [E]) -> a) -> GE (MultiOut [E]) -> a
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> [E] -> MultiOut [E]
f (E -> E -> E -> E -> [E] -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> [E] -> MultiOut [E])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> [E] -> MultiOut [E])
-> GE E -> GE (E -> E -> [E] -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b2 GE (E -> E -> [E] -> MultiOut [E])
-> GE E -> GE (E -> [E] -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b3 GE (E -> [E] -> MultiOut [E]) -> GE E -> GE ([E] -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b4 GE ([E] -> MultiOut [E]) -> GE [E] -> GE (MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (D -> GE E) -> [D] -> GE [E]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM D -> GE E
unD [D]
b5
    where f :: E -> E -> E -> E -> [E] -> MultiOut [E]
f E
a1 E
a2 E
a3 E
a4 [E]
a5 = Name -> Specs -> [E] -> MultiOut [E]
mopcs Name
"vbap8move" ((Rate -> [Rate]
forall a. a -> [a]
repeat Rate
Ar),[Rate
Ar] [Rate] -> [Rate] -> [Rate]
forall a. [a] -> [a] -> [a]
++ (Rate -> [Rate]
forall a. a -> [a]
repeat Rate
Ir)) ([E
a1
                                                                                  ,E
a2
                                                                                  ,E
a3
                                                                                  ,E
a4] [E] -> [E] -> [E]
forall a. [a] -> [a] -> [a]
++ [E]
a5)

-- | 
-- Calculates the gains for a sound location between multiple channels.
--
-- Calculates the gains for a sound location for up to 64.
--
-- > k1[, k2...]  vbapg  kazim [,kelev] [, kspread] [, ilayout]
-- > karray[]  vbapg  kazim [,kelev] [, kspread] [, ilayout]
--
-- csound doc: <http://csound.com/docs/manual/vbapg.html>
vbapg :: Tuple a => Sig -> a
vbapg :: forall a. Tuple a => Sig -> a
vbapg Sig
b1 = GE (MultiOut [E]) -> a
forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple (GE (MultiOut [E]) -> a) -> GE (MultiOut [E]) -> a
forall a b. (a -> b) -> a -> b
$ E -> MultiOut [E]
f (E -> MultiOut [E]) -> GE E -> GE (MultiOut [E])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1
    where f :: E -> MultiOut [E]
f E
a1 = Name -> Specs -> [E] -> MultiOut [E]
mopcs Name
"vbapg" ((Rate -> [Rate]
forall a. a -> [a]
repeat Rate
Kr),[Rate
Kr,Rate
Kr,Rate
Kr,Rate
Ir]) [E
a1]

-- | 
-- Calculates the gains for a sound location between multiple
--       channels with moving virtual sources.
--
-- > kr1[, kr2...]  vbapgmove  idur, ispread, ifldnum, ifld1 \
-- >           [, ifld2] [...]
-- > karray[]  vbapgmove  idur, ispread, ifldnum, ifld1 \
-- >           [, ifld2] [...]
--
-- csound doc: <http://csound.com/docs/manual/vbapgmove.html>
vbapgmove :: Tuple a => D -> D -> D -> D -> a
vbapgmove :: forall a. Tuple a => D -> D -> D -> D -> a
vbapgmove D
b1 D
b2 D
b3 D
b4 = GE (MultiOut [E]) -> a
forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple (GE (MultiOut [E]) -> a) -> GE (MultiOut [E]) -> a
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> MultiOut [E]
f (E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> MultiOut [E])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> D -> GE E
unD D
b1 GE (E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b2 GE (E -> E -> MultiOut [E]) -> GE E -> GE (E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b3 GE (E -> MultiOut [E]) -> GE E -> GE (MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b4
    where f :: E -> E -> E -> E -> MultiOut [E]
f E
a1 E
a2 E
a3 E
a4 = Name -> Specs -> [E] -> MultiOut [E]
mopcs Name
"vbapgmove" ((Rate -> [Rate]
forall a. a -> [a]
repeat Rate
Kr),(Rate -> [Rate]
forall a. a -> [a]
repeat Rate
Ir)) [E
a1,E
a2,E
a3,E
a4]

-- | 
-- Configures VBAP output according to loudspeaker parameters.
--
-- >  vbaplsinit  idim, ilsnum [, idir1] [, idir2] [...] [, idir32]
-- >  vbaplsinit  idim, ilsnum, ilsarray
--
-- csound doc: <http://csound.com/docs/manual/vbaplsinit.html>
vbaplsinit ::  D -> D -> SE ()
vbaplsinit :: D -> D -> SE ()
vbaplsinit D
b1 D
b2 = Dep () -> SE ()
forall a. Dep a -> SE a
SE (Dep () -> SE ()) -> Dep () -> SE ()
forall a b. (a -> b) -> a -> b
$ (E -> Dep ()
forall (m :: * -> *). Monad m => E -> DepT m ()
depT_ (E -> Dep ()) -> DepT GE E -> Dep ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<<) (DepT GE E -> Dep ()) -> DepT GE E -> Dep ()
forall a b. (a -> b) -> a -> b
$ GE E -> DepT GE E
forall (m :: * -> *) a. Monad m => m a -> DepT m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (GE E -> DepT GE E) -> GE E -> DepT GE E
forall a b. (a -> b) -> a -> b
$ E -> E -> E
f (E -> E -> E) -> GE E -> GE (E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> D -> GE E
unD D
b1 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b2
    where f :: E -> E -> E
f E
a1 E
a2 = Name -> Spec1 -> [E] -> E
opcs Name
"vbaplsinit" [(Rate
Xr,(Rate -> [Rate]
forall a. a -> [a]
repeat Rate
Ir))] [E
a1,E
a2]

-- | 
-- Distributes an audio signal among many channels with moving virtual sources.
--
-- Distributes an audio signal among upto 64 channels with moving
--       virtual sources.
--
-- > ar1[, ar2...]  vbapmove  asig, idur, ispread, ifldnum, ifld1 \
-- >           [, ifld2] [...]
-- > aarray[]  vbapmove  asig, idur, ispread, ifldnum, ifld1 \
-- >           [, ifld2] [...]
--
-- csound doc: <http://csound.com/docs/manual/vbapmove.html>
vbapmove :: Tuple a => Sig -> D -> D -> D -> [D] -> a
vbapmove :: forall a. Tuple a => Sig -> D -> D -> D -> [D] -> a
vbapmove Sig
b1 D
b2 D
b3 D
b4 [D]
b5 = GE (MultiOut [E]) -> a
forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple (GE (MultiOut [E]) -> a) -> GE (MultiOut [E]) -> a
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> [E] -> MultiOut [E]
f (E -> E -> E -> E -> [E] -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> [E] -> MultiOut [E])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> [E] -> MultiOut [E])
-> GE E -> GE (E -> E -> [E] -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b2 GE (E -> E -> [E] -> MultiOut [E])
-> GE E -> GE (E -> [E] -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b3 GE (E -> [E] -> MultiOut [E]) -> GE E -> GE ([E] -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b4 GE ([E] -> MultiOut [E]) -> GE [E] -> GE (MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (D -> GE E) -> [D] -> GE [E]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM D -> GE E
unD [D]
b5
    where f :: E -> E -> E -> E -> [E] -> MultiOut [E]
f E
a1 E
a2 E
a3 E
a4 [E]
a5 = Name -> Specs -> [E] -> MultiOut [E]
mopcs Name
"vbapmove" ((Rate -> [Rate]
forall a. a -> [a]
repeat Rate
Ar),[Rate
Ar] [Rate] -> [Rate] -> [Rate]
forall a. [a] -> [a] -> [a]
++ (Rate -> [Rate]
forall a. a -> [a]
repeat Rate
Ir)) ([E
a1
                                                                                 ,E
a2
                                                                                 ,E
a3
                                                                                 ,E
a4] [E] -> [E] -> [E]
forall a. [a] -> [a] -> [a]
++ [E]
a5)

-- | 
-- Writes a multi-channel audio signal to a ZAK array.
--
-- >  vbapz  inumchnls, istartndx, asig, kazim [, kelev] [, kspread]
--
-- csound doc: <http://csound.com/docs/manual/vbapz.html>
vbapz ::  D -> D -> Sig -> Sig -> SE ()
vbapz :: D -> D -> Sig -> Sig -> SE ()
vbapz D
b1 D
b2 Sig
b3 Sig
b4 = Dep () -> SE ()
forall a. Dep a -> SE a
SE (Dep () -> SE ()) -> Dep () -> SE ()
forall a b. (a -> b) -> a -> b
$ (E -> Dep ()
forall (m :: * -> *). Monad m => E -> DepT m ()
depT_ (E -> Dep ()) -> DepT GE E -> Dep ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<<) (DepT GE E -> Dep ()) -> DepT GE E -> Dep ()
forall a b. (a -> b) -> a -> b
$ GE E -> DepT GE E
forall (m :: * -> *) a. Monad m => m a -> DepT m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (GE E -> DepT GE E) -> GE E -> DepT GE E
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E
f (E -> E -> E -> E -> E) -> GE E -> GE (E -> E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> D -> GE E
unD D
b1 GE (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b2 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b4
    where f :: E -> E -> E -> E -> E
f E
a1 E
a2 E
a3 E
a4 = Name -> Spec1 -> [E] -> E
opcs Name
"vbapz" [(Rate
Xr,[Rate
Ir,Rate
Ir,Rate
Ar,Rate
Kr,Rate
Kr,Rate
Kr])] [E
a1,E
a2,E
a3,E
a4]

-- | 
-- Writes a multi-channel audio signal to a ZAK array with moving virtual sources.
--
-- >  vbapzmove  inumchnls, istartndx, asig, idur, ispread, ifldnum, ifld1, \
-- >           ifld2, [...]
--
-- csound doc: <http://csound.com/docs/manual/vbapzmove.html>
vbapzmove ::  Sig -> D -> D -> D -> [D] -> SE ()
vbapzmove :: Sig -> D -> D -> D -> [D] -> SE ()
vbapzmove Sig
b1 D
b2 D
b3 D
b4 [D]
b5 = Dep () -> SE ()
forall a. Dep a -> SE a
SE (Dep () -> SE ()) -> Dep () -> SE ()
forall a b. (a -> b) -> a -> b
$ (E -> Dep ()
forall (m :: * -> *). Monad m => E -> DepT m ()
depT_ (E -> Dep ()) -> DepT GE E -> Dep ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<<) (DepT GE E -> Dep ()) -> DepT GE E -> Dep ()
forall a b. (a -> b) -> a -> b
$ GE E -> DepT GE E
forall (m :: * -> *) a. Monad m => m a -> DepT m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (GE E -> DepT GE E) -> GE E -> DepT GE E
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> [E] -> E
f (E -> E -> E -> E -> [E] -> E)
-> GE E -> GE (E -> E -> E -> [E] -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> [E] -> E) -> GE E -> GE (E -> E -> [E] -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b2 GE (E -> E -> [E] -> E) -> GE E -> GE (E -> [E] -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b3 GE (E -> [E] -> E) -> GE E -> GE ([E] -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b4 GE ([E] -> E) -> GE [E] -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (D -> GE E) -> [D] -> GE [E]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM D -> GE E
unD [D]
b5
    where f :: E -> E -> E -> E -> [E] -> E
f E
a1 E
a2 E
a3 E
a4 [E]
a5 = Name -> Spec1 -> [E] -> E
opcs Name
"vbapzmove" [(Rate
Xr,[Rate
Ir,Rate
Ir,Rate
Ar] [Rate] -> [Rate] -> [Rate]
forall a. [a] -> [a] -> [a]
++ (Rate -> [Rate]
forall a. a -> [a]
repeat Rate
Ir))] ([E
a1,E
a2,E
a3,E
a4] [E] -> [E] -> [E]
forall a. [a] -> [a] -> [a]
++ [E]
a5)

-- Reverberation.

-- | 
-- Reverberates an input signal with a flat frequency response.
--
-- > ares  alpass  asig, xrvt, ilpt [, iskip] [, insmps]
--
-- csound doc: <http://csound.com/docs/manual/alpass.html>
alpass ::  Sig -> Sig -> D -> Sig
alpass :: Sig -> Sig -> D -> Sig
alpass Sig
b1 Sig
b2 D
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"alpass" [(Rate
Ar,[Rate
Ar,Rate
Xr,Rate
Ir,Rate
Ir,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- A physical model reverberator.
--
-- babo  stands  for  ball-within-the-box.   It is a physical model reverberator based on the paper by Davide  Rocchesso "The  Ball  within  the Box: a sound-processing metaphor", Computer Music Journal,  Vol  19,  N.4,  pp.45-47,  Winter 1995.
--
-- > a1, a2  babo  asig, ksrcx, ksrcy, ksrcz, irx, iry, irz [, idiff] [, ifno]
--
-- csound doc: <http://csound.com/docs/manual/babo.html>
babo ::  Sig -> Sig -> Sig -> Sig -> D -> D -> D -> (Sig,Sig)
babo :: Sig -> Sig -> Sig -> Sig -> D -> D -> D -> (Sig, Sig)
babo Sig
b1 Sig
b2 Sig
b3 Sig
b4 D
b5 D
b6 D
b7 = GE (MultiOut [E]) -> (Sig, Sig)
forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple (GE (MultiOut [E]) -> (Sig, Sig))
-> GE (MultiOut [E]) -> (Sig, Sig)
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E -> E -> E -> MultiOut [E]
f (E -> E -> E -> E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> E -> E -> E -> MultiOut [E])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b4 GE (E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b5 GE (E -> E -> MultiOut [E]) -> GE E -> GE (E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b6 GE (E -> MultiOut [E]) -> GE E -> GE (MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b7
    where f :: E -> E -> E -> E -> E -> E -> E -> MultiOut [E]
f E
a1 E
a2 E
a3 E
a4 E
a5 E
a6 E
a7 = Name -> Specs -> [E] -> MultiOut [E]
mopcs Name
"babo" ([Rate
Ar,Rate
Ar],[Rate
Ar,Rate
Kr,Rate
Kr,Rate
Kr,Rate
Ir,Rate
Ir,Rate
Ir,Rate
Ir,Rate
Ir]) [E
a1
                                                                                       ,E
a2
                                                                                       ,E
a3
                                                                                       ,E
a4
                                                                                       ,E
a5
                                                                                       ,E
a6
                                                                                       ,E
a7]

-- | 
-- Reverberates an input signal with a “colored” frequency response.
--
-- > ares  comb  asig, krvt, ilpt [, iskip] [, insmps]
--
-- csound doc: <http://csound.com/docs/manual/comb.html>
comb ::  Sig -> Sig -> D -> Sig
comb :: Sig -> Sig -> D -> Sig
comb Sig
b1 Sig
b2 D
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"comb" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Ir,Rate
Ir,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- Reverberates an input signal with a “colored” frequency response.
--
-- Reverberates an input signal with a “colored”
--       frequency response with a FIR filter.
--
-- > ares  combinv  asig, krvt, ilpt [, iskip] [, insmps]
--
-- csound doc: <http://csound.com/docs/manual/combinv.html>
combinv ::  Sig -> Sig -> D -> Sig
combinv :: Sig -> Sig -> D -> Sig
combinv Sig
b1 Sig
b2 D
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"combinv" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Ir,Rate
Ir,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- Opcode version of Jezar's Freeverb
--
-- freeverb is a stereo reverb unit based on Jezar's public domain
-- 		C++ sources, composed of eight parallel comb filters on both
-- 		channels, followed by four allpass units in series. The filters
-- 		on the right channel are slightly detuned compared to the left
-- 		channel in order to create a stereo effect.
--
-- > aoutL, aoutR  freeverb  ainL, ainR, kRoomSize, kHFDamp[, iSRate[, iSkip]] 
--
-- csound doc: <http://csound.com/docs/manual/freeverb.html>
freeverb ::  Sig -> Sig -> Sig -> Sig -> (Sig,Sig)
freeverb :: Sig -> Sig -> Sig -> Sig -> (Sig, Sig)
freeverb Sig
b1 Sig
b2 Sig
b3 Sig
b4 = GE (MultiOut [E]) -> (Sig, Sig)
forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple (GE (MultiOut [E]) -> (Sig, Sig))
-> GE (MultiOut [E]) -> (Sig, Sig)
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> MultiOut [E]
f (E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> MultiOut [E])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> MultiOut [E]) -> GE E -> GE (E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> MultiOut [E]) -> GE E -> GE (MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b4
    where f :: E -> E -> E -> E -> MultiOut [E]
f E
a1 E
a2 E
a3 E
a4 = Name -> Specs -> [E] -> MultiOut [E]
mopcs Name
"freeverb" ([Rate
Ar,Rate
Ar],[Rate
Ar,Rate
Ar,Rate
Kr,Rate
Kr,Rate
Ir,Rate
Ir]) [E
a1,E
a2,E
a3,E
a4]

-- | 
-- Three different nested all-pass filters.
--
-- Three different nested all-pass filters, useful for implementing reverbs.
--
-- > ares  nestedap  asig, imode, imaxdel, idel1, igain1 [, idel2] [, igain2] \
-- >           [, idel3] [, igain3] [, istor]
--
-- csound doc: <http://csound.com/docs/manual/nestedap.html>
nestedap ::  Sig -> D -> D -> D -> D -> Sig
nestedap :: Sig -> D -> D -> D -> D -> Sig
nestedap Sig
b1 D
b2 D
b3 D
b4 D
b5 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E -> E
f (E -> E -> E -> E -> E -> E) -> GE E -> GE (E -> E -> E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E -> E) -> GE E -> GE (E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b2 GE (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b3 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b4 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b5
    where f :: E -> E -> E -> E -> E -> E
f E
a1 E
a2 E
a3 E
a4 E
a5 = Name -> Spec1 -> [E] -> E
opcs Name
"nestedap" [(Rate
Ar,[Rate
Ar,Rate
Ir,Rate
Ir,Rate
Ir,Rate
Ir,Rate
Ir,Rate
Ir,Rate
Ir,Rate
Ir,Rate
Ir])] [E
a1,E
a2,E
a3,E
a4,E
a5]

-- | 
-- A reverberator consisting of 6 parallel comb-lowpass filters.
--
-- This is a reverberator consisting of 6 parallel comb-lowpass filters being fed into a series of 5 allpass filters. nreverb replaces reverb2 (version 3.48) and so both opcodes are identical.
--
-- > ares  nreverb  asig, ktime, khdif [, iskip] [,inumCombs] [, ifnCombs] \
-- >           [, inumAlpas] [, ifnAlpas]
--
-- csound doc: <http://csound.com/docs/manual/nreverb.html>
nreverb ::  Sig -> Sig -> Sig -> Sig
nreverb :: Sig -> Sig -> Sig -> Sig
nreverb Sig
b1 Sig
b2 Sig
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"nreverb" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Kr,Rate
Ir,Rate
Ir,Rate
Ir,Rate
Ir,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- Models the reverberation of a metal plate.
--
-- Models the reverberation of a rectangular metal plate with
--       settable physical characteristics when excited by audio signal(s).
--
-- > a1[, a2, ...]  platerev  itabexcite. itabouts, kbndry, iaspect, istiff, idecay, iloss, aexcite1[, aexcite2, ...]
--
-- csound doc: <http://csound.com/docs/manual/platerev.html>
platerev :: Tuple a => D -> D -> Sig -> D -> D -> D -> D -> [Sig] -> a
platerev :: forall a.
Tuple a =>
D -> D -> Sig -> D -> D -> D -> D -> [Sig] -> a
platerev D
b1 D
b2 Sig
b3 D
b4 D
b5 D
b6 D
b7 [Sig]
b8 = GE (MultiOut [E]) -> a
forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple (GE (MultiOut [E]) -> a) -> GE (MultiOut [E]) -> a
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E -> E -> E -> [E] -> MultiOut [E]
f (E -> E -> E -> E -> E -> E -> E -> [E] -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> E -> E -> E -> [E] -> MultiOut [E])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> D -> GE E
unD D
b1 GE (E -> E -> E -> E -> E -> E -> [E] -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> E -> E -> [E] -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b2 GE (E -> E -> E -> E -> E -> [E] -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> E -> [E] -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> E -> E -> E -> [E] -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> [E] -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b4 GE (E -> E -> E -> [E] -> MultiOut [E])
-> GE E -> GE (E -> E -> [E] -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b5 GE (E -> E -> [E] -> MultiOut [E])
-> GE E -> GE (E -> [E] -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b6 GE (E -> [E] -> MultiOut [E]) -> GE E -> GE ([E] -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b7 GE ([E] -> MultiOut [E]) -> GE [E] -> GE (MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Sig -> GE E) -> [Sig] -> GE [E]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM Sig -> GE E
unSig [Sig]
b8
    where f :: E -> E -> E -> E -> E -> E -> E -> [E] -> MultiOut [E]
f E
a1 E
a2 E
a3 E
a4 E
a5 E
a6 E
a7 [E]
a8 = Name -> Specs -> [E] -> MultiOut [E]
mopcs Name
"platerev" ((Rate -> [Rate]
forall a. a -> [a]
repeat Rate
Ar)
                                                       ,[Rate
Ir,Rate
Ir,Rate
Kr,Rate
Ir,Rate
Ir,Rate
Ir,Rate
Ir] [Rate] -> [Rate] -> [Rate]
forall a. [a] -> [a] -> [a]
++ (Rate -> [Rate]
forall a. a -> [a]
repeat Rate
Ar)) ([E
a1,E
a2,E
a3,E
a4,E
a5,E
a6,E
a7] [E] -> [E] -> [E]
forall a. [a] -> [a] -> [a]
++ [E]
a8)

-- | 
-- Reverberates an input signal with a “natural room” frequency response.
--
-- > ares  reverb  asig, krvt [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/reverb.html>
reverb ::  Sig -> Sig -> Sig
reverb :: Sig -> Sig -> Sig
reverb Sig
b1 Sig
b2 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E
f (E -> E -> E) -> GE E -> GE (E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2
    where f :: E -> E -> E
f E
a1 E
a2 = Name -> Spec1 -> [E] -> E
opcs Name
"reverb" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Ir])] [E
a1,E
a2]

-- | 
-- Same as the nreverb opcode.
--
-- > ares  reverb2  asig, ktime, khdif [, iskip] [,inumCombs] \
-- >           [, ifnCombs] [, inumAlpas] [, ifnAlpas]
--
-- csound doc: <http://csound.com/docs/manual/reverb2.html>
reverb2 ::  Sig -> Sig -> Sig -> Sig
reverb2 :: Sig -> Sig -> Sig -> Sig
reverb2 Sig
b1 Sig
b2 Sig
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"reverb2" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Kr,Rate
Ir,Rate
Ir,Rate
Ir,Rate
Ir,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- 8 delay line stereo FDN reverb, based on work by Sean Costello
--
-- 8 delay line stereo FDN reverb, with feedback matrix based upon physical
-- 		modeling scattering junction of 8 lossless waveguides of equal characteristic
-- 		impedance. Based on Csound orchestra version by Sean Costello.
--
-- > aoutL, aoutR  reverbsc  ainL, ainR, kfblvl, kfco[, israte[, ipitchm[, iskip]]] 
--
-- csound doc: <http://csound.com/docs/manual/reverbsc.html>
reverbsc ::  Sig -> Sig -> Sig -> Sig -> (Sig,Sig)
reverbsc :: Sig -> Sig -> Sig -> Sig -> (Sig, Sig)
reverbsc Sig
b1 Sig
b2 Sig
b3 Sig
b4 = GE (MultiOut [E]) -> (Sig, Sig)
forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple (GE (MultiOut [E]) -> (Sig, Sig))
-> GE (MultiOut [E]) -> (Sig, Sig)
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> MultiOut [E]
f (E -> E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> E -> MultiOut [E])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> MultiOut [E]) -> GE E -> GE (E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> MultiOut [E]) -> GE E -> GE (MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b4
    where f :: E -> E -> E -> E -> MultiOut [E]
f E
a1 E
a2 E
a3 E
a4 = Name -> Specs -> [E] -> MultiOut [E]
mopcs Name
"reverbsc" ([Rate
Ar,Rate
Ar],[Rate
Ar,Rate
Ar,Rate
Kr,Rate
Kr,Rate
Ir,Rate
Ir,Rate
Ir]) [E
a1,E
a2,E
a3,E
a4]

-- | 
-- Variably reverberates an input signal with a flat frequency response.
--
-- > ares  valpass  asig, krvt, xlpt, imaxlpt [, iskip] [, insmps]
--
-- csound doc: <http://csound.com/docs/manual/valpass.html>
valpass ::  Sig -> Sig -> Sig -> D -> Sig
valpass :: Sig -> Sig -> Sig -> D -> Sig
valpass Sig
b1 Sig
b2 Sig
b3 D
b4 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E
f (E -> E -> E -> E -> E) -> GE E -> GE (E -> E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b4
    where f :: E -> E -> E -> E -> E
f E
a1 E
a2 E
a3 E
a4 = Name -> Spec1 -> [E] -> E
opcs Name
"valpass" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Xr,Rate
Ir,Rate
Ir,Rate
Ir])] [E
a1,E
a2,E
a3,E
a4]

-- | 
-- Variably reverberates an input signal with a “colored” frequency response.
--
-- > ares  vcomb  asig, krvt, xlpt, imaxlpt [, iskip] [, insmps]
--
-- csound doc: <http://csound.com/docs/manual/vcomb.html>
vcomb ::  Sig -> Sig -> Sig -> D -> Sig
vcomb :: Sig -> Sig -> Sig -> D -> Sig
vcomb Sig
b1 Sig
b2 Sig
b3 D
b4 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E
f (E -> E -> E -> E -> E) -> GE E -> GE (E -> E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b4
    where f :: E -> E -> E -> E -> E
f E
a1 E
a2 E
a3 E
a4 = Name -> Spec1 -> [E] -> E
opcs Name
"vcomb" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Xr,Rate
Ir,Rate
Ir,Rate
Ir])] [E
a1,E
a2,E
a3,E
a4]

-- Sample Level Operators.

-- | 
-- Mixes low level noise to a list of a-rate signals
--
-- Mixes low level (~1e-20 for floats, and ~1e-56 for doubles)
--     	noise to a list of a-rate signals. Can be used before IIR
--     	filters and reverbs to avoid denormalized numbers which may
--     	otherwise result in significantly increased CPU usage.
--
-- >  denorm  a1[, a2[, a3[, ... ]]]
--
-- csound doc: <http://csound.com/docs/manual/denorm.html>
denorm ::  [Sig] -> SE ()
denorm :: [Sig] -> SE ()
denorm [Sig]
b1 = Dep () -> SE ()
forall a. Dep a -> SE a
SE (Dep () -> SE ()) -> Dep () -> SE ()
forall a b. (a -> b) -> a -> b
$ (E -> Dep ()
forall (m :: * -> *). Monad m => E -> DepT m ()
depT_ (E -> Dep ()) -> DepT GE E -> Dep ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<<) (DepT GE E -> Dep ()) -> DepT GE E -> Dep ()
forall a b. (a -> b) -> a -> b
$ GE E -> DepT GE E
forall (m :: * -> *) a. Monad m => m a -> DepT m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (GE E -> DepT GE E) -> GE E -> DepT GE E
forall a b. (a -> b) -> a -> b
$ [E] -> E
f ([E] -> E) -> GE [E] -> GE E
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Sig -> GE E) -> [Sig] -> GE [E]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM Sig -> GE E
unSig [Sig]
b1
    where f :: [E] -> E
f [E]
a1 = Name -> Spec1 -> [E] -> E
opcs Name
"denorm" [(Rate
Xr,(Rate -> [Rate]
forall a. a -> [a]
repeat Rate
Ar))] [E]
a1

-- | 
-- Modify a signal by differentiation.
--
-- > ares  diff  asig [, iskip]
-- > kres  diff  ksig [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/diff.html>
diff ::  Sig -> Sig
diff :: Sig -> Sig
diff Sig
b1 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E
f (E -> E) -> GE E -> GE E
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1
    where f :: E -> E
f E
a1 = Name -> Spec1 -> [E] -> E
opcs Name
"diff" [(Rate
Ar,[Rate
Ar,Rate
Ir]),(Rate
Kr,[Rate
Kr,Rate
Ir])] [E
a1]

-- | 
-- Modify a signal by down-sampling.
--
-- > kres  downsamp  asig [, iwlen]
--
-- csound doc: <http://csound.com/docs/manual/downsamp.html>
downsamp ::  Sig -> Sig
downsamp :: Sig -> Sig
downsamp Sig
b1 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E
f (E -> E) -> GE E -> GE E
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1
    where f :: E -> E
f E
a1 = Name -> Spec1 -> [E] -> E
opcs Name
"downsamp" [(Rate
Kr,[Rate
Ar,Rate
Ir])] [E
a1]

-- | 
-- Adds artificial foldover to an audio signal.
--
-- > ares  fold  asig, kincr
--
-- csound doc: <http://csound.com/docs/manual/fold.html>
fold ::  Sig -> Sig -> Sig
fold :: Sig -> Sig -> Sig
fold Sig
b1 Sig
b2 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E
f (E -> E -> E) -> GE E -> GE (E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2
    where f :: E -> E -> E
f E
a1 E
a2 = Name -> Spec1 -> [E] -> E
opcs Name
"fold" [(Rate
Ar,[Rate
Ar,Rate
Kr])] [E
a1,E
a2]

-- | 
-- Modify a signal by integration.
--
-- > ares  integ  asig [, iskip]
-- > kres  integ  ksig [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/integ.html>
integ ::  Sig -> Sig
integ :: Sig -> Sig
integ Sig
b1 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E
f (E -> E) -> GE E -> GE E
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1
    where f :: E -> E
f E
a1 = Name -> Spec1 -> [E] -> E
opcs Name
"integ" [(Rate
Ar,[Rate
Ar,Rate
Ir]),(Rate
Kr,[Rate
Kr,Rate
Ir])] [E
a1]

-- | 
-- Converts a control signal to an audio signal using linear interpolation.
--
-- > ares  interp  ksig [, iskip] [, imode]
-- >         [, ivalue]
--
-- csound doc: <http://csound.com/docs/manual/interp.html>
interp ::  Sig -> Sig
interp :: Sig -> Sig
interp Sig
b1 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E
f (E -> E) -> GE E -> GE E
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1
    where f :: E -> E
f E
a1 = Name -> Spec1 -> [E] -> E
opcs Name
"interp" [(Rate
Ar,[Rate
Kr,Rate
Ir,Rate
Ir,Rate
Ir])] [E
a1]

-- | 
-- Calculates the weighted mean value of two input signals.
--
-- Calculates the weighted mean value (i.e. linear interpolation) of two input signals
--
-- > ares  ntrpol  asig1, asig2, kpoint [, imin] [, imax]
-- > ires  ntrpol  isig1, isig2, ipoint [, imin] [, imax]
-- > kres  ntrpol  ksig1, ksig2, kpoint [, imin] [, imax]
--
-- csound doc: <http://csound.com/docs/manual/ntrpol.html>
ntrpol ::  Sig -> Sig -> Sig -> Sig
ntrpol :: Sig -> Sig -> Sig -> Sig
ntrpol Sig
b1 Sig
b2 Sig
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"ntrpol" [(Rate
Ar,[Rate
Ar,Rate
Ar,Rate
Kr,Rate
Ir,Rate
Ir])
                                     ,(Rate
Ir,[Rate
Ir,Rate
Ir,Rate
Ir,Rate
Ir,Rate
Ir])
                                     ,(Rate
Kr,[Rate
Kr,Rate
Kr,Rate
Kr,Rate
Ir,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- Performs a sample-and-hold operation on its input.
--
-- > ares  samphold  asig, agate [, ival] [, ivstor]
-- > kres  samphold  ksig, kgate [, ival] [, ivstor]
--
-- csound doc: <http://csound.com/docs/manual/samphold.html>
samphold ::  Sig -> Sig -> Sig
samphold :: Sig -> Sig -> Sig
samphold Sig
b1 Sig
b2 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E
f (E -> E -> E) -> GE E -> GE (E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2
    where f :: E -> E -> E
f E
a1 E
a2 = Name -> Spec1 -> [E] -> E
opcs Name
"samphold" [(Rate
Ar,[Rate
Ar,Rate
Ar,Rate
Ir,Rate
Ir]),(Rate
Kr,[Rate
Kr,Rate
Kr,Rate
Ir,Rate
Ir])] [E
a1,E
a2]

-- | 
-- Modify a signal by up-sampling.
--
-- > ares  upsamp  ksig
--
-- csound doc: <http://csound.com/docs/manual/upsamp.html>
upsamp ::  Sig -> Sig
upsamp :: Sig -> Sig
upsamp Sig
b1 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E
f (E -> E) -> GE E -> GE E
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1
    where f :: E -> E
f E
a1 = Name -> Spec1 -> [E] -> E
opcs Name
"upsamp" [(Rate
Ar,[Rate
Kr])] [E
a1]

-- | 
-- Access values of the current buffer of an a-rate variable by indexing.
--
-- Access values of the current buffer of an a-rate variable by indexing.
--       Useful for doing sample-by-sample manipulation at k-rate without using
--       setksmps 1.
--
-- > kval  vaget  kndx, avar
--
-- csound doc: <http://csound.com/docs/manual/vaget.html>
vaget ::  Sig -> Sig -> Sig
vaget :: Sig -> Sig -> Sig
vaget Sig
b1 Sig
b2 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E
f (E -> E -> E) -> GE E -> GE (E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2
    where f :: E -> E -> E
f E
a1 E
a2 = Name -> Spec1 -> [E] -> E
opcs Name
"vaget" [(Rate
Kr,[Rate
Kr,Rate
Ar])] [E
a1,E
a2]

-- | 
-- Write value of into the current buffer of an a-rate variable by index.
--
-- Write values into the current buffer of an a-rate variable at the given
--       index.  Useful for doing sample-by-sample manipulation at k-rate without
--       using setksmps 1.
--
-- >  vaset  kval, kndx, avar
--
-- csound doc: <http://csound.com/docs/manual/vaset.html>
vaset ::  Sig -> Sig -> Sig -> SE ()
vaset :: Sig -> Sig -> Sig -> SE ()
vaset Sig
b1 Sig
b2 Sig
b3 = Dep () -> SE ()
forall a. Dep a -> SE a
SE (Dep () -> SE ()) -> Dep () -> SE ()
forall a b. (a -> b) -> a -> b
$ (E -> Dep ()
forall (m :: * -> *). Monad m => E -> DepT m ()
depT_ (E -> Dep ()) -> DepT GE E -> Dep ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<<) (DepT GE E -> Dep ()) -> DepT GE E -> Dep ()
forall a b. (a -> b) -> a -> b
$ GE E -> DepT GE E
forall (m :: * -> *) a. Monad m => m a -> DepT m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (GE E -> DepT GE E) -> GE E -> DepT GE E
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"vaset" [(Rate
Xr,[Rate
Kr,Rate
Kr,Rate
Ar])] [E
a1,E
a2,E
a3]

-- Signal Limiters.

-- | 
-- Sets the lower and upper limits of the value it processes.
--
-- > ares  limit  asig, klow, khigh
-- > ires  limit  isig, ilow, ihigh
-- > kres  limit  ksig, klow, khigh
-- > ires[]  limit  isig[], ilow, ihigh
-- > kres[]  limit  ksig[], klow, khigh
--
-- csound doc: <http://csound.com/docs/manual/limit.html>
limit ::  Sig -> Sig -> Sig -> Sig
limit :: Sig -> Sig -> Sig -> Sig
limit Sig
b1 Sig
b2 Sig
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"limit" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Kr])
                                    ,(Rate
Ir,[Rate
Ir,Rate
Ir,Rate
Ir])
                                    ,(Rate
Kr,[Rate
Kr,Rate
Kr,Rate
Kr])
                                    ,(Rate
Ir,[Rate
Ir,Rate
Ir,Rate
Ir])
                                    ,(Rate
Kr,[Rate
Kr,Rate
Kr,Rate
Kr])] [E
a1,E
a2,E
a3]

-- | 
-- Reflects the signal that exceeds the low and high thresholds.
--
-- > ares  mirror  asig, klow, khigh
-- > ires  mirror  isig, ilow, ihigh
-- > kres  mirror  ksig, klow, khigh
--
-- csound doc: <http://csound.com/docs/manual/mirror.html>
mirror ::  Sig -> Sig -> Sig -> Sig
mirror :: Sig -> Sig -> Sig -> Sig
mirror Sig
b1 Sig
b2 Sig
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"mirror" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Kr]),(Rate
Ir,[Rate
Ir,Rate
Ir,Rate
Ir]),(Rate
Kr,[Rate
Kr,Rate
Kr,Rate
Kr])] [E
a1,E
a2,E
a3]

-- | 
-- Wraps-around the signal that exceeds the low and high thresholds.
--
-- > ares  wrap  asig, klow, khigh
-- > ires  wrap  isig, ilow, ihigh
-- > kres  wrap  ksig, klow, khigh
--
-- csound doc: <http://csound.com/docs/manual/wrap.html>
wrap ::  Sig -> Sig -> Sig -> Sig
wrap :: Sig -> Sig -> Sig -> Sig
wrap Sig
b1 Sig
b2 Sig
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"wrap" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Kr]),(Rate
Ir,[Rate
Ir,Rate
Ir,Rate
Ir]),(Rate
Kr,[Rate
Kr,Rate
Kr,Rate
Kr])] [E
a1,E
a2,E
a3]

-- Special Effects.

-- | 
-- Distort an audio signal via waveshaping and optional clipping.
--
-- > ar  distort  asig, kdist, ifn[, ihp, istor]
--
-- csound doc: <http://csound.com/docs/manual/distort.html>
distort ::  Sig -> Sig -> Tab -> Sig
distort :: Sig -> Sig -> Tab -> Sig
distort Sig
b1 Sig
b2 Tab
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Tab -> GE E
unTab Tab
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"distort" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Ir,Rate
Ir,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- Modified hyperbolic tangent distortion.
--
-- Implementation of modified hyperbolic tangent distortion. distort1 can be used to generate wave shaping distortion based on a modification of the tanh function.
--
-- > ares  distort1  asig, kpregain, kpostgain, kshape1, kshape2[, imode]
--
-- csound doc: <http://csound.com/docs/manual/distort1.html>
distort1 ::  Sig -> Sig -> Sig -> Sig -> Sig -> Sig
distort1 :: Sig -> Sig -> Sig -> Sig -> Sig -> Sig
distort1 Sig
b1 Sig
b2 Sig
b3 Sig
b4 Sig
b5 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E -> E
f (E -> E -> E -> E -> E -> E) -> GE E -> GE (E -> E -> E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E -> E) -> GE E -> GE (E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b4 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b5
    where f :: E -> E -> E -> E -> E -> E
f E
a1 E
a2 E
a3 E
a4 E
a5 = Name -> Spec1 -> [E] -> E
opcs Name
"distort1" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Kr,Rate
Kr,Rate
Kr,Rate
Ir])] [E
a1,E
a2,E
a3,E
a4,E
a5]

-- | 
-- A user controlled flanger.
--
-- > ares  flanger  asig, adel, kfeedback [, imaxd]
--
-- csound doc: <http://csound.com/docs/manual/flanger.html>
flanger ::  Sig -> Sig -> Sig -> Sig
flanger :: Sig -> Sig -> Sig -> Sig
flanger Sig
b1 Sig
b2 Sig
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"flanger" [(Rate
Ar,[Rate
Ar,Rate
Ar,Rate
Kr,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- Analyze an audio input and generate harmonizing voices in synchrony.
--
-- > ares  harmon  asig, kestfrq, kmaxvar, kgenfreq1, kgenfreq2, imode, \
-- >           iminfrq, iprd
--
-- csound doc: <http://csound.com/docs/manual/harmon.html>
harmon ::  Sig -> Sig -> Sig -> Sig -> Sig -> D -> D -> D -> Sig
harmon :: Sig -> Sig -> Sig -> Sig -> Sig -> D -> D -> D -> Sig
harmon Sig
b1 Sig
b2 Sig
b3 Sig
b4 Sig
b5 D
b6 D
b7 D
b8 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E -> E -> E -> E -> E
f (E -> E -> E -> E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E -> E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b4 GE (E -> E -> E -> E -> E) -> GE E -> GE (E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b5 GE (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b6 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b7 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b8
    where f :: E -> E -> E -> E -> E -> E -> E -> E -> E
f E
a1 E
a2 E
a3 E
a4 E
a5 E
a6 E
a7 E
a8 = Name -> Spec1 -> [E] -> E
opcs Name
"harmon" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Kr,Rate
Kr,Rate
Kr,Rate
Ir,Rate
Ir,Rate
Ir])] [E
a1
                                                                                     ,E
a2
                                                                                     ,E
a3
                                                                                     ,E
a4
                                                                                     ,E
a5
                                                                                     ,E
a6
                                                                                     ,E
a7
                                                                                     ,E
a8]

-- | 
-- Analyze an audio input and generate harmonizing voices in
--       synchrony with formants preserved.
--
-- Generate harmonizing voices with formants preserved.
--
-- > ares  harmon2  asig, koct, kfrq1, kfrq2, icpsmode, ilowest[, ipolarity]
--
-- csound doc: <http://csound.com/docs/manual/harmon2.html>
harmon2 ::  Sig -> Sig -> Sig -> Sig -> D -> D -> Sig
harmon2 :: Sig -> Sig -> Sig -> Sig -> D -> D -> Sig
harmon2 Sig
b1 Sig
b2 Sig
b3 Sig
b4 D
b5 D
b6 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E -> E -> E
f (E -> E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> E -> E -> E) -> GE E -> GE (E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b4 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b5 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b6
    where f :: E -> E -> E -> E -> E -> E -> E
f E
a1 E
a2 E
a3 E
a4 E
a5 E
a6 = Name -> Spec1 -> [E] -> E
opcs Name
"harmon2" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Kr,Rate
Kr,Rate
Ir,Rate
Ir,Rate
Ir])] [E
a1,E
a2,E
a3,E
a4,E
a5,E
a6]

-- | 
-- Analyze an audio input and generate harmonizing voices in
--       synchrony with formants preserved.
--
-- Generate harmonizing voices with formants preserved.
--
-- > ares  harmon3  asig, koct, kfrq1, \
-- >         kfrq2, kfrq3, icpsmode, ilowest[, ipolarity]
--
-- csound doc: <http://csound.com/docs/manual/harmon2.html>
harmon3 ::  Sig -> Sig -> Sig -> Sig -> Sig -> D -> D -> Sig
harmon3 :: Sig -> Sig -> Sig -> Sig -> Sig -> D -> D -> Sig
harmon3 Sig
b1 Sig
b2 Sig
b3 Sig
b4 Sig
b5 D
b6 D
b7 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E -> E -> E -> E
f (E -> E -> E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> E -> E -> E -> E) -> GE E -> GE (E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b4 GE (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b5 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b6 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b7
    where f :: E -> E -> E -> E -> E -> E -> E -> E
f E
a1 E
a2 E
a3 E
a4 E
a5 E
a6 E
a7 = Name -> Spec1 -> [E] -> E
opcs Name
"harmon3" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Kr,Rate
Kr,Rate
Kr,Rate
Ir,Rate
Ir,Rate
Ir])] [E
a1
                                                                                   ,E
a2
                                                                                   ,E
a3
                                                                                   ,E
a4
                                                                                   ,E
a5
                                                                                   ,E
a6
                                                                                   ,E
a7]

-- | 
-- Analyze an audio input and generate harmonizing voices in
--       synchrony with formants preserved.
--
-- Generate harmonizing voices with formants preserved.
--
-- > ares  harmon4  asig, koct, kfrq1, \
-- >         kfrq2, kfrq3, kfrq4, icpsmode, ilowest[, ipolarity]
--
-- csound doc: <http://csound.com/docs/manual/harmon2.html>
harmon4 ::  Sig -> Sig -> Sig -> Sig -> Sig -> Sig -> D -> D -> Sig
harmon4 :: Sig -> Sig -> Sig -> Sig -> Sig -> Sig -> D -> D -> Sig
harmon4 Sig
b1 Sig
b2 Sig
b3 Sig
b4 Sig
b5 Sig
b6 D
b7 D
b8 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E -> E -> E -> E -> E
f (E -> E -> E -> E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E -> E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b4 GE (E -> E -> E -> E -> E) -> GE E -> GE (E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b5 GE (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b6 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b7 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b8
    where f :: E -> E -> E -> E -> E -> E -> E -> E -> E
f E
a1 E
a2 E
a3 E
a4 E
a5 E
a6 E
a7 E
a8 = Name -> Spec1 -> [E] -> E
opcs Name
"harmon4" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Kr,Rate
Kr,Rate
Kr,Rate
Kr,Rate
Ir,Rate
Ir,Rate
Ir])] [E
a1
                                                                                         ,E
a2
                                                                                         ,E
a3
                                                                                         ,E
a4
                                                                                         ,E
a5
                                                                                         ,E
a6
                                                                                         ,E
a7
                                                                                         ,E
a8]

-- | 
-- First-order allpass filters arranged in a series.
--
-- An implementation of iord number of first-order allpass filters in series.
--
-- > ares  phaser1  asig, kfreq, kord, kfeedback [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/phaser1.html>
phaser1 ::  Sig -> Sig -> Sig -> Sig -> Sig
phaser1 :: Sig -> Sig -> Sig -> Sig -> Sig
phaser1 Sig
b1 Sig
b2 Sig
b3 Sig
b4 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E
f (E -> E -> E -> E -> E) -> GE E -> GE (E -> E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b4
    where f :: E -> E -> E -> E -> E
f E
a1 E
a2 E
a3 E
a4 = Name -> Spec1 -> [E] -> E
opcs Name
"phaser1" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Kr,Rate
Kr,Rate
Ir])] [E
a1,E
a2,E
a3,E
a4]

-- | 
-- Second-order allpass filters arranged in a series.
--
-- An implementation of iord number of second-order allpass filters in series.
--
-- > ares  phaser2  asig, kfreq, kq, kord, kmode, ksep, kfeedback
--
-- csound doc: <http://csound.com/docs/manual/phaser2.html>
phaser2 ::  Sig -> Sig -> Sig -> Sig -> Sig -> Sig -> Sig -> Sig
phaser2 :: Sig -> Sig -> Sig -> Sig -> Sig -> Sig -> Sig -> Sig
phaser2 Sig
b1 Sig
b2 Sig
b3 Sig
b4 Sig
b5 Sig
b6 Sig
b7 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E -> E -> E -> E
f (E -> E -> E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> E -> E -> E -> E) -> GE E -> GE (E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b4 GE (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b5 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b6 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b7
    where f :: E -> E -> E -> E -> E -> E -> E -> E
f E
a1 E
a2 E
a3 E
a4 E
a5 E
a6 E
a7 = Name -> Spec1 -> [E] -> E
opcs Name
"phaser2" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Kr,Rate
Kr,Rate
Kr,Rate
Kr,Rate
Kr])] [E
a1
                                                                                ,E
a2
                                                                                ,E
a3
                                                                                ,E
a4
                                                                                ,E
a5
                                                                                ,E
a6
                                                                                ,E
a7]

-- Standard Filters.

-- | 
-- A hi-pass filter whose transfer functions are the complements of the tone opcode.
--
-- > ares  atone  asig, khp [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/atone.html>
atone ::  Sig -> Sig -> Sig
atone :: Sig -> Sig -> Sig
atone Sig
b1 Sig
b2 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E
f (E -> E -> E) -> GE E -> GE (E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2
    where f :: E -> E -> E
f E
a1 E
a2 = Name -> Spec1 -> [E] -> E
opcs Name
"atone" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Ir])] [E
a1,E
a2]

-- | 
-- Emulates a stack of filters using the atone opcode.
--
-- atonex is equivalent to a filter consisting of more layers of atone with the same arguments, serially connected. Using a stack of a larger number of filters allows a sharper cutoff. They are faster than using a larger number instances in a Csound orchestra of the old opcodes, because only one initialization and k- cycle are needed at time and the audio loop falls entirely inside the cache memory of processor.
--
-- > ares  atonex  asig, khp [, inumlayer] [, iskip]
-- > ares  atonex  asig, ahp [, inumlayer] [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/atonex.html>
atonex ::  Sig -> Sig -> Sig
atonex :: Sig -> Sig -> Sig
atonex Sig
b1 Sig
b2 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E
f (E -> E -> E) -> GE E -> GE (E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2
    where f :: E -> E -> E
f E
a1 E
a2 = Name -> Spec1 -> [E] -> E
opcs Name
"atonex" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Ir,Rate
Ir]),(Rate
Ar,[Rate
Ar,Rate
Ar,Rate
Ir,Rate
Ir])] [E
a1,E
a2]

-- | 
-- A sweepable general purpose biquadratic digital filter.
--
-- > ares  biquad  asig, kb0, kb1, kb2, ka0, ka1, ka2 [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/biquad.html>
biquad ::  Sig -> Sig -> Sig -> Sig -> Sig -> Sig -> Sig -> Sig
biquad :: Sig -> Sig -> Sig -> Sig -> Sig -> Sig -> Sig -> Sig
biquad Sig
b1 Sig
b2 Sig
b3 Sig
b4 Sig
b5 Sig
b6 Sig
b7 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E -> E -> E -> E
f (E -> E -> E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> E -> E -> E -> E) -> GE E -> GE (E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b4 GE (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b5 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b6 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b7
    where f :: E -> E -> E -> E -> E -> E -> E -> E
f E
a1 E
a2 E
a3 E
a4 E
a5 E
a6 E
a7 = Name -> Spec1 -> [E] -> E
opcs Name
"biquad" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Kr,Rate
Kr,Rate
Kr,Rate
Kr,Rate
Kr,Rate
Ir])] [E
a1
                                                                                  ,E
a2
                                                                                  ,E
a3
                                                                                  ,E
a4
                                                                                  ,E
a5
                                                                                  ,E
a6
                                                                                  ,E
a7]

-- | 
-- A sweepable general purpose biquadratic digital filter with a-rate parameters.
--
-- A sweepable general purpose biquadratic digital filter.
--
-- > ares  biquada  asig, ab0, ab1, ab2, aa0, aa1, aa2 [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/biquada.html>
biquada ::  Sig -> Sig -> Sig -> Sig -> Sig -> Sig -> Sig -> Sig
biquada :: Sig -> Sig -> Sig -> Sig -> Sig -> Sig -> Sig -> Sig
biquada Sig
b1 Sig
b2 Sig
b3 Sig
b4 Sig
b5 Sig
b6 Sig
b7 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E -> E -> E -> E
f (E -> E -> E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> E -> E -> E -> E) -> GE E -> GE (E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b4 GE (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b5 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b6 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b7
    where f :: E -> E -> E -> E -> E -> E -> E -> E
f E
a1 E
a2 E
a3 E
a4 E
a5 E
a6 E
a7 = Name -> Spec1 -> [E] -> E
opcs Name
"biquada" [(Rate
Ar,[Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ir])] [E
a1
                                                                                   ,E
a2
                                                                                   ,E
a3
                                                                                   ,E
a4
                                                                                   ,E
a5
                                                                                   ,E
a6
                                                                                   ,E
a7]

-- | 
-- Same as the butterbp opcode.
--
-- > ares  butbp  asig, kfreq, kband [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/butbp.html>
butbp ::  Sig -> Sig -> Sig -> Sig
butbp :: Sig -> Sig -> Sig -> Sig
butbp Sig
b1 Sig
b2 Sig
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"butbp" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Kr,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- Same as the butterbr opcode.
--
-- > ares  butbr  asig, kfreq, kband [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/butbr.html>
butbr ::  Sig -> Sig -> Sig -> Sig
butbr :: Sig -> Sig -> Sig -> Sig
butbr Sig
b1 Sig
b2 Sig
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"butbr" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Kr,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- Same as the butterhp opcode.
--
-- > ares  buthp  asig, kfreq [, iskip]
-- > ares  buthp  asig, afreq [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/buthp.html>
buthp ::  Sig -> Sig -> Sig
buthp :: Sig -> Sig -> Sig
buthp Sig
b1 Sig
b2 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E
f (E -> E -> E) -> GE E -> GE (E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2
    where f :: E -> E -> E
f E
a1 E
a2 = Name -> Spec1 -> [E] -> E
opcs Name
"buthp" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Ir]),(Rate
Ar,[Rate
Ar,Rate
Ar,Rate
Ir])] [E
a1,E
a2]

-- | 
-- Same as the butterlp opcode.
--
-- > ares  butlp  asig, kfreq [, iskip]
-- > ares  butlp  asig, afreq [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/butlp.html>
butlp ::  Sig -> Sig -> Sig
butlp :: Sig -> Sig -> Sig
butlp Sig
b1 Sig
b2 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E
f (E -> E -> E) -> GE E -> GE (E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2
    where f :: E -> E -> E
f E
a1 E
a2 = Name -> Spec1 -> [E] -> E
opcs Name
"butlp" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Ir]),(Rate
Ar,[Rate
Ar,Rate
Ar,Rate
Ir])] [E
a1,E
a2]

-- | 
-- A band-pass Butterworth filter.
--
-- Implementation of a second-order band-pass Butterworth filter. This opcode can also be written as butbp.
--
-- > ares  butterbp  asig, xfreq, xband [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/butterbp.html>
butterbp ::  Sig -> Sig -> Sig -> Sig
butterbp :: Sig -> Sig -> Sig -> Sig
butterbp Sig
b1 Sig
b2 Sig
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"butterbp" [(Rate
Ar,[Rate
Ar,Rate
Xr,Rate
Xr,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- A band-reject Butterworth filter.
--
-- Implementation of a second-order band-reject Butterworth filter. This opcode can also be written as butbr.
--
-- > ares  butterbr  asig, xfreq, xband [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/butterbr.html>
butterbr ::  Sig -> Sig -> Sig -> Sig
butterbr :: Sig -> Sig -> Sig -> Sig
butterbr Sig
b1 Sig
b2 Sig
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"butterbr" [(Rate
Ar,[Rate
Ar,Rate
Xr,Rate
Xr,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- A high-pass Butterworth filter.
--
-- Implementation of second-order high-pass Butterworth filter. This opcode can also be written as buthp.
--
-- > ares  butterhp  asig, kfreq [, iskip]
-- > ares  butterhp  asig, afreq [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/butterhp.html>
butterhp ::  Sig -> Sig -> Sig
butterhp :: Sig -> Sig -> Sig
butterhp Sig
b1 Sig
b2 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E
f (E -> E -> E) -> GE E -> GE (E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2
    where f :: E -> E -> E
f E
a1 E
a2 = Name -> Spec1 -> [E] -> E
opcs Name
"butterhp" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Ir]),(Rate
Ar,[Rate
Ar,Rate
Ar,Rate
Ir])] [E
a1,E
a2]

-- | 
-- A low-pass Butterworth filter.
--
-- Implementation of a second-order low-pass Butterworth filter. This opcode can also be written as butlp.
--
-- > ares  butterlp  asig, kfreq [, iskip]
-- > ares  butterlp  asig, afreq [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/butterlp.html>
butterlp ::  Sig -> Sig -> Sig
butterlp :: Sig -> Sig -> Sig
butterlp Sig
b1 Sig
b2 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E
f (E -> E -> E) -> GE E -> GE (E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2
    where f :: E -> E -> E
f E
a1 E
a2 = Name -> Spec1 -> [E] -> E
opcs Name
"butterlp" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Ir]),(Rate
Ar,[Rate
Ar,Rate
Ar,Rate
Ir])] [E
a1,E
a2]

-- | 
-- Implements low-pass and high-pass filters of different styles.
--
-- Implements the classical standard analog filter types: low-pass and high-pass. They are implemented with the four classical kinds of filters: Butterworth, Chebyshev Type I, Chebyshev Type II, and Elliptical.  The number of poles may be any even number from 2 to 80.
--
-- > ares  clfilt  asig, kfreq, itype, inpol [, ikind] [, ipbr] [, isba] [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/clfilt.html>
clfilt ::  Sig -> Sig -> D -> D -> Sig
clfilt :: Sig -> Sig -> D -> D -> Sig
clfilt Sig
b1 Sig
b2 D
b3 D
b4 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E
f (E -> E -> E -> E -> E) -> GE E -> GE (E -> E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b3 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b4
    where f :: E -> E -> E -> E -> E
f E
a1 E
a2 E
a3 E
a4 = Name -> Spec1 -> [E] -> E
opcs Name
"clfilt" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Ir,Rate
Ir,Rate
Ir,Rate
Ir,Rate
Ir,Rate
Ir])] [E
a1,E
a2,E
a3,E
a4]

-- | 
-- Zero-delay feedback implementation of 4 pole diode ladder filter.
--
-- Zero-delay feedback implementation of a 4 pole (24 dB/oct) diode low-pass filter. This filter design was originally used in the EMS VCS3 and was the resonant filter in the Roland TB-303.
--
-- > asig  diode_ladder  ain, xcf, xk [, inlp, isaturation, istor]
--
-- csound doc: <http://csound.com/docs/manual/diode_ladder.html>
diode_ladder ::  Sig -> Sig -> Sig -> Sig
diode_ladder :: Sig -> Sig -> Sig -> Sig
diode_ladder Sig
b1 Sig
b2 Sig
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"diode_ladder" [(Rate
Ar,[Rate
Ar,Rate
Xr,Rate
Xr,Rate
Ir,Rate
Ir,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- A fast and robust method for approximating sound propagation, achieving convincing Doppler shifts without having to solve equations.
--
-- A fast and robust method for approximating sound propagation, achieving convincing Doppler shifts without having to solve equations. The method computes frequency shifts based on reading an input delay line at a delay time computed from the distance between source and mic and the speed of sound. One instance of the opcode is required for each dimension of space through which the sound source moves. If the source sound moves at a constant speed from in front of the microphone, through the microphone, to behind the microphone, then the output will be frequency shifted above the source frequency at a constant frequency while the source approaches, then discontinuously will be shifted below the source frequency at a constant frequency as the source recedes from the microphone. If the source sound moves at a constant speed through a point to one side of the microphone, then the rate of change of position will not be constant, and the familiar Doppler frequency shift typical of a siren or engine approaching and receding along a road beside a listener will be heard.
--
-- > ashifted  doppler  asource, ksourceposition, kmicposition [, isoundspeed, ifiltercutoff]
--
-- csound doc: <http://csound.com/docs/manual/doppler.html>
doppler ::  Sig -> Sig -> Sig -> Sig
doppler :: Sig -> Sig -> Sig -> Sig
doppler Sig
b1 Sig
b2 Sig
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"doppler" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Kr,Rate
Ir,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- Zero-delay feedback implementation of Korg35 resonant high-pass filter.
--
-- Zero-delay feedback implementation of Korg35 resonant high-pass filter. This filter design is found in the Korg MS10 early MS20.
--
-- > asig  K35_hpf  ain, xcf, xQ [, inlp, isaturation, istor]
--
-- csound doc: <http://csound.com/docs/manual/k35_hpf.html>
k35_hpf ::  Sig -> Sig -> Sig -> Sig
k35_hpf :: Sig -> Sig -> Sig -> Sig
k35_hpf Sig
b1 Sig
b2 Sig
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"K35_hpf" [(Rate
Ar,[Rate
Ar,Rate
Xr,Rate
Xr,Rate
Ir,Rate
Ir,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- Zero-delay feedback implementation of Korg35 resonant low-pass filter.
--
-- Zero-delay feedback implementation of Korg35 resonant low-pass filter. This filter design is found in the Korg MS10, early MS20, and Monotron series.
--
-- > asig  K35_lpf  ain, xcf, xQ [, inlp, isaturation, istor]
--
-- csound doc: <http://csound.com/docs/manual/k35_lpf.html>
k35_lpf ::  Sig -> Sig -> Sig -> Sig
k35_lpf :: Sig -> Sig -> Sig -> Sig
k35_lpf Sig
b1 Sig
b2 Sig
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"K35_lpf" [(Rate
Ar,[Rate
Ar,Rate
Xr,Rate
Xr,Rate
Ir,Rate
Ir,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- A median filter, a variant FIR lowpass filter.
--
-- Implementation of a median filter.
--
-- > ares  median  asig, ksize, imaxsize [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/median.html>
median ::  Sig -> Sig -> D -> Sig
median :: Sig -> Sig -> D -> Sig
median Sig
b1 Sig
b2 D
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"median" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Ir,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- A median filter, a variant FIR lowpass filter.
--
-- Implementation of a median filter.
--
-- > kres  mediank  kin, ksize, imaxsize [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/mediank.html>
mediank ::  Sig -> Sig -> D -> Sig
mediank :: Sig -> Sig -> D -> Sig
mediank Sig
b1 Sig
b2 D
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"mediank" [(Rate
Kr,[Rate
Kr,Rate
Kr,Rate
Ir,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- A filter that simulates a mass-spring-damper system
--
-- Filters the incoming signal with the specified resonance frequency and
--       quality factor. It can also be seen as a signal generator for high quality
--       factor, with an impulse for the excitation. You can combine several modes
--       to built complex instruments such as bells or guitar tables.
--
-- > aout  mode  ain, xfreq, xQ [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/mode.html>
mode ::  Sig -> Sig -> Sig -> Sig
mode :: Sig -> Sig -> Sig -> Sig
mode Sig
b1 Sig
b2 Sig
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"mode" [(Rate
Ar,[Rate
Ar,Rate
Xr,Rate
Xr,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- A first-order recursive low-pass filter with variable frequency response.
--
-- > ares  tone  asig, khp [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/tone.html>
tone ::  Sig -> Sig -> Sig
tone :: Sig -> Sig -> Sig
tone Sig
b1 Sig
b2 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E
f (E -> E -> E) -> GE E -> GE (E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2
    where f :: E -> E -> E
f E
a1 E
a2 = Name -> Spec1 -> [E] -> E
opcs Name
"tone" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Ir])] [E
a1,E
a2]

-- | 
-- Emulates a stack of filters using the tone opcode.
--
-- tonex is equivalent to a filter consisting of more layers of tone with the same arguments, serially connected. Using a stack of a larger number of filters allows a sharper cutoff. They are faster than using a larger number instances in a Csound orchestra of the old opcodes, because only one initialization and k- cycle are needed at time and the audio loop falls entirely inside the cache memory of processor.
--
-- > ares  tonex   asig, khp [, inumlayer] [, iskip]
-- > ares  tonex   asig, ahp [, inumlayer] [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/tonex.html>
tonex ::  Sig -> Sig -> Sig
tonex :: Sig -> Sig -> Sig
tonex Sig
b1 Sig
b2 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E
f (E -> E -> E) -> GE E -> GE (E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2
    where f :: E -> E -> E
f E
a1 E
a2 = Name -> Spec1 -> [E] -> E
opcs Name
"tonex" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Ir,Rate
Ir]),(Rate
Ar,[Rate
Ar,Rate
Ar,Rate
Ir,Rate
Ir])] [E
a1,E
a2]

-- | 
-- Zero-delay feedback implementation of 1 pole filter.
--
-- Zero-delay feedback implementation of a 1 pole (6 dB/oct) filter. Offers low-pass (default), high-pass, and allpass output modes.
--
-- > asig  zdf_1pole  ain, xcf [, kmode, istor]
--
-- csound doc: <http://csound.com/docs/manual/zdf_1pole.html>
zdf_1pole ::  Sig -> Sig -> Sig
zdf_1pole :: Sig -> Sig -> Sig
zdf_1pole Sig
b1 Sig
b2 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E
f (E -> E -> E) -> GE E -> GE (E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2
    where f :: E -> E -> E
f E
a1 E
a2 = Name -> Spec1 -> [E] -> E
opcs Name
"zdf_1pole" [(Rate
Ar,[Rate
Ar,Rate
Xr,Rate
Kr,Rate
Ir])] [E
a1,E
a2]

-- | 
-- Zero-delay feedback implementation of 1 pole filter with multimode output.
--
-- Zero-delay feedback implementation of a 1 pole (6 dB/oct) filter. Offers low-pass and high-pass output.
--
-- > alp, ahp  zdf_1pole_mode  ain, xcf [, istor]
--
-- csound doc: <http://csound.com/docs/manual/zdf_1pole_mode.html>
zdf_1pole_mode ::  Sig -> Sig -> (Sig,Sig)
zdf_1pole_mode :: Sig -> Sig -> (Sig, Sig)
zdf_1pole_mode Sig
b1 Sig
b2 = GE (MultiOut [E]) -> (Sig, Sig)
forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple (GE (MultiOut [E]) -> (Sig, Sig))
-> GE (MultiOut [E]) -> (Sig, Sig)
forall a b. (a -> b) -> a -> b
$ E -> E -> MultiOut [E]
f (E -> E -> MultiOut [E]) -> GE E -> GE (E -> MultiOut [E])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> MultiOut [E]) -> GE E -> GE (MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2
    where f :: E -> E -> MultiOut [E]
f E
a1 E
a2 = Name -> Specs -> [E] -> MultiOut [E]
mopcs Name
"zdf_1pole_mode" ([Rate
Ar,Rate
Ar],[Rate
Ar,Rate
Xr,Rate
Ir]) [E
a1,E
a2]

-- | 
-- Zero-delay feedback implementation of 2 pole filter.
--
-- Zero-delay feedback implementation of a 2 pole (12 dB/oct) filter. Offers low-pass (default), high-pass, and allpass output modes.
--
-- > asig  zdf_2pole  ain, xcf, xQ [, kmode, istor]
--
-- csound doc: <http://csound.com/docs/manual/zdf_2pole.html>
zdf_2pole ::  Sig -> Sig -> Sig -> Sig
zdf_2pole :: Sig -> Sig -> Sig -> Sig
zdf_2pole Sig
b1 Sig
b2 Sig
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"zdf_2pole" [(Rate
Ar,[Rate
Ar,Rate
Xr,Rate
Xr,Rate
Kr,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- Zero-delay feedback implementation of 2 pole filter with multimode output.
--
-- Zero-delay feedback implementation of a 2 pole (12 dB/oct) filter. Offers low-pass,
--       band-pass, and high-pass output.
--
-- > alp, abp, ahp  zdf_2pole_mode  ain, xcf, Q [, istor]
--
-- csound doc: <http://csound.com/docs/manual/zdf_2pole_mode.html>
zdf_2pole_mode ::  Sig -> Sig -> Sig -> (Sig,Sig,Sig)
zdf_2pole_mode :: Sig -> Sig -> Sig -> (Sig, Sig, Sig)
zdf_2pole_mode Sig
b1 Sig
b2 Sig
b3 = GE (MultiOut [E]) -> (Sig, Sig, Sig)
forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple (GE (MultiOut [E]) -> (Sig, Sig, Sig))
-> GE (MultiOut [E]) -> (Sig, Sig, Sig)
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> MultiOut [E]
f (E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> MultiOut [E])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> MultiOut [E]) -> GE E -> GE (E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> MultiOut [E]) -> GE E -> GE (MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> MultiOut [E]
f E
a1 E
a2 E
a3 = Name -> Specs -> [E] -> MultiOut [E]
mopcs Name
"zdf_2pole_mode" ([Rate
Ar,Rate
Ar,Rate
Ar],[Rate
Ar,Rate
Xr,Rate
Xr,Rate
Ir]) [E
a1,E
a2,E
a3]

-- | 
-- Zero-delay feedback implementation of 4 pole ladder filter.
--
-- Zero-delay feedback implementation of a 4 pole (24 dB/oct) low-pass filter based on the Moog ladder filter.
--
-- > asig  zdf_ladder  ain, xcf, xQ [, istor]
--
-- csound doc: <http://csound.com/docs/manual/zdf_ladder.html>
zdf_ladder ::  Sig -> Sig -> Sig -> Sig
zdf_ladder :: Sig -> Sig -> Sig -> Sig
zdf_ladder Sig
b1 Sig
b2 Sig
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"zdf_ladder" [(Rate
Ar,[Rate
Ar,Rate
Xr,Rate
Xr,Rate
Ir])] [E
a1,E
a2,E
a3]

-- Standard Filters:Resonant.

-- | 
-- A notch filter whose transfer functions are the complements of
--       the reson opcode.
--
-- > ares  areson  asig, kcf, kbw [, iscl] [, iskip]
-- > ares  areson  asig, acf, kbw [, iscl] [, iskip]
-- > ares  areson  asig, kcf, abw [, iscl] [, iskip]
-- > ares  areson  asig, acf, abw [, iscl] [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/areson.html>
areson ::  Sig -> Sig -> Sig -> Sig
areson :: Sig -> Sig -> Sig -> Sig
areson Sig
b1 Sig
b2 Sig
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"areson" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Kr,Rate
Ir,Rate
Ir])
                                     ,(Rate
Ar,[Rate
Ar,Rate
Ar,Rate
Kr,Rate
Ir,Rate
Ir])
                                     ,(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Ar,Rate
Ir,Rate
Ir])
                                     ,(Rate
Ar,[Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ir,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- A second-order multi-mode filter.
--
-- > ares  bqrez  asig, xfco, xres [, imode] [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/bqrez.html>
bqrez ::  Sig -> Sig -> Sig -> Sig
bqrez :: Sig -> Sig -> Sig -> Sig
bqrez Sig
b1 Sig
b2 Sig
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"bqrez" [(Rate
Ar,[Rate
Ar,Rate
Xr,Rate
Xr,Rate
Ir,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- A resonant lowpass filter.
--
-- Implementation of a resonant second-order lowpass filter.
--
-- > ares  lowpass2  asig, kcf, kq [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/lowpass2.html>
lowpass2 ::  Sig -> Sig -> Sig -> Sig
lowpass2 :: Sig -> Sig -> Sig -> Sig
lowpass2 Sig
b1 Sig
b2 Sig
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"lowpass2" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Kr,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- Another resonant lowpass filter.
--
-- lowres is a resonant lowpass filter.
--
-- > ares  lowres  asig, kcutoff, kresonance [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/lowres.html>
lowres ::  Sig -> Sig -> Sig -> Sig
lowres :: Sig -> Sig -> Sig -> Sig
lowres Sig
b1 Sig
b2 Sig
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"lowres" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Kr,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- Simulates layers of serially connected resonant lowpass filters.
--
-- lowresx is equivalent to more layers of lowres with the same arguments serially connected.
--
-- > ares  lowresx  asig, xcutoff, xresonance [, inumlayer] [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/lowresx.html>
lowresx ::  Sig -> Sig -> Sig -> Sig
lowresx :: Sig -> Sig -> Sig -> Sig
lowresx Sig
b1 Sig
b2 Sig
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"lowresx" [(Rate
Ar,[Rate
Ar,Rate
Xr,Rate
Xr,Rate
Ir,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- A 3-pole sweepable resonant lowpass filter.
--
-- Implementation of a 3 pole sweepable resonant lowpass filter.
--
-- > ares  lpf18  asig, xfco, xres, xdist [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/lpf18.html>
lpf18 ::  Sig -> Sig -> Sig -> Sig -> Sig
lpf18 :: Sig -> Sig -> Sig -> Sig -> Sig
lpf18 Sig
b1 Sig
b2 Sig
b3 Sig
b4 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E
f (E -> E -> E -> E -> E) -> GE E -> GE (E -> E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b4
    where f :: E -> E -> E -> E -> E
f E
a1 E
a2 E
a3 E
a4 = Name -> Spec1 -> [E] -> E
opcs Name
"lpf18" [(Rate
Ar,[Rate
Ar,Rate
Xr,Rate
Xr,Rate
Xr,Rate
Ir])] [E
a1,E
a2,E
a3,E
a4]

-- | 
-- Moog ladder lowpass filter.
--
-- Moogladder is an new digital implementation of the Moog ladder filter based on 
-- the work of Antti Huovilainen, described in the paper "Non-Linear Digital 
-- Implementation of the Moog Ladder Filter" (Proceedings of DaFX04, Univ of Napoli). 
-- This implementation is probably a more accurate digital representation of 
-- the original analogue filter.
--
-- > asig  moogladder  ain, kcf, kres[, istor]
-- > asig  moogladder  ain, acf, kres[, istor]
-- > asig  moogladder  ain, kcf, ares[, istor]
-- > asig  moogladder  ain, acf, ares[, istor]
--
-- csound doc: <http://csound.com/docs/manual/moogladder.html>
moogladder ::  Sig -> Sig -> Sig -> Sig
moogladder :: Sig -> Sig -> Sig -> Sig
moogladder Sig
b1 Sig
b2 Sig
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"moogladder" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Kr,Rate
Ir])
                                         ,(Rate
Ar,[Rate
Ar,Rate
Ar,Rate
Kr,Rate
Ir])
                                         ,(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Ar,Rate
Ir])
                                         ,(Rate
Ar,[Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- Moog ladder lowpass filter.
--
-- Moogladder2 is an new digital implementation of the Moog ladder filter based on 
-- the work of Antti Huovilainen, described in the paper "Non-Linear Digital 
-- Implementation of the Moog Ladder Filter" (Proceedings of DaFX04, Univ of Napoli). 
-- This implementation uses approximations to the tanh function and so is
-- faster but less accurate than moogladder.
--
-- > asig  moogladder2  ain, kcf, kres[, istor]
-- > asig  moogladder2  ain, acf, kres[, istor]
-- > asig  moogladder2  ain, kcf, ares[, istor]
-- > asig  moogladder2  ain, acf, ares[, istor]
--
-- csound doc: <http://csound.com/docs/manual/moogladder2.html>
moogladder2 ::  Sig -> Sig -> Sig -> Sig
moogladder2 :: Sig -> Sig -> Sig -> Sig
moogladder2 Sig
b1 Sig
b2 Sig
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"moogladder2" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Kr,Rate
Ir])
                                          ,(Rate
Ar,[Rate
Ar,Rate
Ar,Rate
Kr,Rate
Ir])
                                          ,(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Ar,Rate
Ir])
                                          ,(Rate
Ar,[Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- A digital emulation of the Moog diode ladder filter configuration.
--
-- > ares  moogvcf  asig, xfco, xres [,iscale, iskip]
--
-- csound doc: <http://csound.com/docs/manual/moogvcf.html>
moogvcf ::  Sig -> Sig -> Sig -> Sig
moogvcf :: Sig -> Sig -> Sig -> Sig
moogvcf Sig
b1 Sig
b2 Sig
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"moogvcf" [(Rate
Ar,[Rate
Ar,Rate
Xr,Rate
Xr,Rate
Ir,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- A digital emulation of the Moog diode ladder filter configuration.
--
-- > ares  moogvcf2  asig, xfco, xres [,iscale, iskip]
--
-- csound doc: <http://csound.com/docs/manual/moogvcf2.html>
moogvcf2 ::  Sig -> Sig -> Sig -> Sig
moogvcf2 :: Sig -> Sig -> Sig -> Sig
moogvcf2 Sig
b1 Sig
b2 Sig
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"moogvcf2" [(Rate
Ar,[Rate
Ar,Rate
Xr,Rate
Xr,Rate
Ir,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- Moog voltage-controlled highpass filter emulation.
--
-- Mvchpf is an digital implementation of the 4th-order (24 dB/oct)  Moog
-- high-pass filter, originally written by Fons Andriaensen. According to the author,
-- mvchpf "...is based on the voltage controlled highpass filter by Robert Moog.
-- again with some attention to the nonlinear effects."
--
-- > asig  mvchpf  ain, xcf[, istor]
--
-- csound doc: <http://csound.com/docs/manual/mvchpf.html>
mvchpf ::  Sig -> Sig -> Sig
mvchpf :: Sig -> Sig -> Sig
mvchpf Sig
b1 Sig
b2 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E
f (E -> E -> E) -> GE E -> GE (E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2
    where f :: E -> E -> E
f E
a1 E
a2 = Name -> Spec1 -> [E] -> E
opcs Name
"mvchpf" [(Rate
Ar,[Rate
Ar,Rate
Xr,Rate
Ir])] [E
a1,E
a2]

-- | 
-- Moog voltage-controlled lowpass filter emulation.
--
-- Mvclpf1 is an digital implementation of the 4th-order (24 dB/oct)  Moog ladder filter
-- originally written by Fons Andriaensen. According to the author,
-- mvclpf1 "is a fairly simple design, and it does not even pretend to come
-- close the 'real thing'. It uses a very crude approximation of the non-linear
-- resistor in the first filter section only. [...] [I]t's [a] cheap (in
-- terms of CPU usage) general purpose 24 dB/oct lowpass
-- filter that could be useful".
--
-- > asig  mvclpf1  ain, xcf, xres[,istor]
--
-- csound doc: <http://csound.com/docs/manual/mvclpf1.html>
mvclpf1 ::  Sig -> Sig -> Sig -> Sig
mvclpf1 :: Sig -> Sig -> Sig -> Sig
mvclpf1 Sig
b1 Sig
b2 Sig
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"mvclpf1" [(Rate
Ar,[Rate
Ar,Rate
Xr,Rate
Xr,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- Moog voltage-controlled lowpass filter emulation.
--
-- Mvclpf2 is an digital implementation of the 4th-order (24 dB/oct) Moog ladder filter
-- originally written by Fons Andriaensen. According to the author,
-- mvclpf2 "uses five non-linear elements, in the input and in all four filter
-- sections. It works by using the derivative of the nonlinearity (for which
-- 1 / (1 + x * x) is reasonable approximation). The main advantage of this is
-- that only one evaluation of the non-linear function is required for each
-- section".
--
-- > asig  mvclpf2  ain, xcf, xres[, istor]
--
-- csound doc: <http://csound.com/docs/manual/mvclpf2.html>
mvclpf2 ::  Sig -> Sig -> Sig -> Sig
mvclpf2 :: Sig -> Sig -> Sig -> Sig
mvclpf2 Sig
b1 Sig
b2 Sig
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"mvclpf2" [(Rate
Ar,[Rate
Ar,Rate
Xr,Rate
Xr,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- Moog voltage-controlled lowpass filter emulation.
--
-- Mvclpf3 is an digital implementation of the 4th-order (24 dB/oct) Moog ladder filter
-- originally written by Fons Andriaensen. According to the author,
-- mvclpf3 "is based on mvclpf2 , with two differences. It uses the
-- the technique described by Stilson and Smith to extend the constant-Q
-- range, and the internal sample frequency is doubled, giving a better
-- approximation to the non-linear behaviour at high freqencies.
-- This version has high Q over the entire frequency range and will
-- oscillate up to above 10 kHz, while the two others show a decreasing
-- Q at high frequencies. Mvclpf3  is reasonably well tuned, and can be
-- 'played' as a VCO up to at least 5 kHz".
--
-- > asig  mvclpf3  ain, xcf, xres[, istor]
--
-- csound doc: <http://csound.com/docs/manual/mvclpf3.html>
mvclpf3 ::  Sig -> Sig -> Sig -> Sig
mvclpf3 :: Sig -> Sig -> Sig -> Sig
mvclpf3 Sig
b1 Sig
b2 Sig
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"mvclpf3" [(Rate
Ar,[Rate
Ar,Rate
Xr,Rate
Xr,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- Moog voltage-controlled lowpass filter emulation.
--
-- Mvclpf4 is an digital implementation of the 4th-order (24 dB/oct) Moog ladder filter
-- originally written by Fons Andriaensen. It is a version of the
-- mvclpf3 opcode with four outputs, for 6dB, 12dB, 18dB, and
-- 24 dB/octave responses.
--
-- > asig1,asig2,asig3,asig4  mvclpf4  ain, xcf, xres[, istor]
--
-- csound doc: <http://csound.com/docs/manual/mvclpf4.html>
mvclpf4 ::  Sig -> Sig -> Sig -> (Sig,Sig,Sig,Sig)
mvclpf4 :: Sig -> Sig -> Sig -> (Sig, Sig, Sig, Sig)
mvclpf4 Sig
b1 Sig
b2 Sig
b3 = GE (MultiOut [E]) -> (Sig, Sig, Sig, Sig)
forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple (GE (MultiOut [E]) -> (Sig, Sig, Sig, Sig))
-> GE (MultiOut [E]) -> (Sig, Sig, Sig, Sig)
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> MultiOut [E]
f (E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> MultiOut [E])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> MultiOut [E]) -> GE E -> GE (E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> MultiOut [E]) -> GE E -> GE (MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> MultiOut [E]
f E
a1 E
a2 E
a3 = Name -> Specs -> [E] -> MultiOut [E]
mopcs Name
"mvclpf4" ([Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar],[Rate
Ar,Rate
Xr,Rate
Xr,Rate
Ir]) [E
a1,E
a2,E
a3]

-- | 
-- A second-order resonant filter.
--
-- > ares  reson  asig, xcf, xbw [, iscl] [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/reson.html>
reson ::  Sig -> Sig -> Sig -> Sig
reson :: Sig -> Sig -> Sig -> Sig
reson Sig
b1 Sig
b2 Sig
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"reson" [(Rate
Ar,[Rate
Ar,Rate
Xr,Rate
Xr,Rate
Ir,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- A bandpass filter with variable frequency response.
--
-- Implementations of a second-order, two-pole two-zero bandpass filter with variable frequency response.
--
-- > ares  resonr  asig, xcf, xbw [, iscl] [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/resonr.html>
resonr ::  Sig -> Sig -> Sig -> Sig
resonr :: Sig -> Sig -> Sig -> Sig
resonr Sig
b1 Sig
b2 Sig
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"resonr" [(Rate
Ar,[Rate
Ar,Rate
Xr,Rate
Xr,Rate
Ir,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- Emulates a stack of filters using the reson opcode.
--
-- resonx is equivalent to a filters consisting of more layers of reson with the same arguments, serially connected. Using a stack of a larger number of filters allows a sharper cutoff. They are faster than using a larger number instances in a Csound orchestra of the old opcodes, because only one initialization and k- cycle are needed at time and the audio loop falls entirely inside the cache memory of processor.
--
-- > ares  resonx  asig, xcf, xbw [, inumlayer] [, iscl] [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/resonx.html>
resonx ::  Sig -> Sig -> Sig -> Sig
resonx :: Sig -> Sig -> Sig -> Sig
resonx Sig
b1 Sig
b2 Sig
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"resonx" [(Rate
Ar,[Rate
Ar,Rate
Xr,Rate
Xr,Rate
Ir,Rate
Ir,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- A bank of second-order bandpass filters, connected in parallel.
--
-- > ares  resony  asig, kbf, kbw, inum, ksep [, isepmode] [, iscl] [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/resony.html>
resony ::  Sig -> Sig -> Sig -> D -> Sig -> Sig
resony :: Sig -> Sig -> Sig -> D -> Sig -> Sig
resony Sig
b1 Sig
b2 Sig
b3 D
b4 Sig
b5 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E -> E
f (E -> E -> E -> E -> E -> E) -> GE E -> GE (E -> E -> E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E -> E) -> GE E -> GE (E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b4 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b5
    where f :: E -> E -> E -> E -> E -> E
f E
a1 E
a2 E
a3 E
a4 E
a5 = Name -> Spec1 -> [E] -> E
opcs Name
"resony" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Kr,Rate
Ir,Rate
Kr,Rate
Ir,Rate
Ir,Rate
Ir])] [E
a1,E
a2,E
a3,E
a4,E
a5]

-- | 
-- A bandpass filter with variable frequency response.
--
-- Implementations of a second-order, two-pole two-zero bandpass filter with variable frequency response.
--
-- > ares  resonz  asig, xcf, xbw [, iscl] [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/resonz.html>
resonz ::  Sig -> Sig -> Sig -> Sig
resonz :: Sig -> Sig -> Sig -> Sig
resonz Sig
b1 Sig
b2 Sig
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"resonz" [(Rate
Ar,[Rate
Ar,Rate
Xr,Rate
Xr,Rate
Ir,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- A resonant low-pass filter.
--
-- > ares  rezzy  asig, xfco, xres [, imode, iskip]
--
-- csound doc: <http://csound.com/docs/manual/rezzy.html>
rezzy ::  Sig -> Sig -> Sig -> Sig
rezzy :: Sig -> Sig -> Sig -> Sig
rezzy Sig
b1 Sig
b2 Sig
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"rezzy" [(Rate
Ar,[Rate
Ar,Rate
Xr,Rate
Xr,Rate
Ir,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- State-variable filter.
--
-- Statevar is a new digital implementation of the analogue state-variable filter. 
-- This filter has four simultaneous outputs: high-pass, low-pass,
-- band-pass and band-reject. This filter uses oversampling for sharper
-- resonance (default: 3 times oversampling). It includes a
-- resonance limiter that prevents the filter from getting unstable.
--
-- > ahp,alp,abp,abr  statevar  ain, xcf, xq [, iosamps, istor]
--
-- csound doc: <http://csound.com/docs/manual/statevar.html>
statevar ::  Sig -> Sig -> Sig -> (Sig,Sig,Sig,Sig)
statevar :: Sig -> Sig -> Sig -> (Sig, Sig, Sig, Sig)
statevar Sig
b1 Sig
b2 Sig
b3 = GE (MultiOut [E]) -> (Sig, Sig, Sig, Sig)
forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple (GE (MultiOut [E]) -> (Sig, Sig, Sig, Sig))
-> GE (MultiOut [E]) -> (Sig, Sig, Sig, Sig)
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> MultiOut [E]
f (E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> MultiOut [E])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> MultiOut [E]) -> GE E -> GE (E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> MultiOut [E]) -> GE E -> GE (MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> MultiOut [E]
f E
a1 E
a2 E
a3 = Name -> Specs -> [E] -> MultiOut [E]
mopcs Name
"statevar" ([Rate
Ar,Rate
Ar,Rate
Ar,Rate
Ar],[Rate
Ar,Rate
Xr,Rate
Xr,Rate
Ir,Rate
Ir]) [E
a1,E
a2,E
a3]

-- | 
-- A resonant second order filter, with simultaneous lowpass, highpass and bandpass outputs.
--
-- Implementation of a resonant second order filter, with simultaneous lowpass, highpass and bandpass outputs.
--
-- > alow, ahigh, aband  svfilter   asig, kcf, kq [, iscl] [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/svfilter.html>
svfilter ::  Sig -> Sig -> Sig -> (Sig,Sig,Sig)
svfilter :: Sig -> Sig -> Sig -> (Sig, Sig, Sig)
svfilter Sig
b1 Sig
b2 Sig
b3 = GE (MultiOut [E]) -> (Sig, Sig, Sig)
forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple (GE (MultiOut [E]) -> (Sig, Sig, Sig))
-> GE (MultiOut [E]) -> (Sig, Sig, Sig)
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> MultiOut [E]
f (E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> MultiOut [E])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> MultiOut [E]) -> GE E -> GE (E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> MultiOut [E]) -> GE E -> GE (MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> MultiOut [E]
f E
a1 E
a2 E
a3 = Name -> Specs -> [E] -> MultiOut [E]
mopcs Name
"svfilter" ([Rate
Ar,Rate
Ar,Rate
Ar],[Rate
Ar,Rate
Kr,Rate
Kr,Rate
Ir,Rate
Ir]) [E
a1,E
a2,E
a3]

-- | 
-- Models some of the filter characteristics of a Roland TB303 voltage-controlled filter.
--
-- This opcode attempts to model some of the filter characteristics of a Roland TB303 voltage-controlled filter. Euler's method is used to approximate the system, rather than traditional filter methods. Cutoff frequency, Q, and distortion are all coupled. Empirical methods were used to try to unentwine,  but frequency is only approximate as a result. Future fixes for some problems with this opcode may break existing orchestras relying on this version of tbvcf.
--
-- > ares  tbvcf  asig, xfco, xres, kdist, kasym [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/tbvcf.html>
tbvcf ::  Sig -> Sig -> Sig -> Sig -> Sig -> Sig
tbvcf :: Sig -> Sig -> Sig -> Sig -> Sig -> Sig
tbvcf Sig
b1 Sig
b2 Sig
b3 Sig
b4 Sig
b5 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E -> E
f (E -> E -> E -> E -> E -> E) -> GE E -> GE (E -> E -> E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E -> E) -> GE E -> GE (E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b4 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b5
    where f :: E -> E -> E -> E -> E -> E
f E
a1 E
a2 E
a3 E
a4 E
a5 = Name -> Spec1 -> [E] -> E
opcs Name
"tbvcf" [(Rate
Ar,[Rate
Ar,Rate
Xr,Rate
Xr,Rate
Kr,Rate
Kr,Rate
Ir])] [E
a1,E
a2,E
a3,E
a4,E
a5]

-- | 
-- A bank of filters in which the cutoff frequency can be separated under user control.
--
-- A bank of filters in which the cutoff frequency can be separated under user control
--
-- > ares  vlowres  asig, kfco, kres, iord, ksep
--
-- csound doc: <http://csound.com/docs/manual/vlowres.html>
vlowres ::  Sig -> Sig -> Sig -> D -> Sig -> Sig
vlowres :: Sig -> Sig -> Sig -> D -> Sig -> Sig
vlowres Sig
b1 Sig
b2 Sig
b3 D
b4 Sig
b5 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E -> E
f (E -> E -> E -> E -> E -> E) -> GE E -> GE (E -> E -> E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E -> E) -> GE E -> GE (E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b4 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b5
    where f :: E -> E -> E -> E -> E -> E
f E
a1 E
a2 E
a3 E
a4 E
a5 = Name -> Spec1 -> [E] -> E
opcs Name
"vlowres" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Kr,Rate
Ir,Rate
Kr])] [E
a1,E
a2,E
a3,E
a4,E
a5]

-- Standard Filters:Control.

-- | 
-- A notch filter whose transfer functions are the complements of the reson opcode.
--
-- > kres  aresonk  ksig, kcf, kbw [, iscl] [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/aresonk.html>
aresonk ::  Sig -> Sig -> Sig -> Sig
aresonk :: Sig -> Sig -> Sig -> Sig
aresonk Sig
b1 Sig
b2 Sig
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"aresonk" [(Rate
Kr,[Rate
Kr,Rate
Kr,Rate
Kr,Rate
Ir,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- A hi-pass filter whose transfer functions are the complements of the tonek opcode.
--
-- > kres  atonek  ksig, khp [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/atonek.html>
atonek ::  Sig -> Sig -> Sig
atonek :: Sig -> Sig -> Sig
atonek Sig
b1 Sig
b2 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E
f (E -> E -> E) -> GE E -> GE (E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2
    where f :: E -> E -> E
f E
a1 E
a2 = Name -> Spec1 -> [E] -> E
opcs Name
"atonek" [(Rate
Kr,[Rate
Kr,Rate
Kr,Rate
Ir])] [E
a1,E
a2]

-- | 
-- Generate glissandos starting from a control signal.
--
-- > kres  lineto  ksig, ktime
--
-- csound doc: <http://csound.com/docs/manual/lineto.html>
lineto ::  Sig -> Sig -> Sig
lineto :: Sig -> Sig -> Sig
lineto Sig
b1 Sig
b2 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E
f (E -> E -> E) -> GE E -> GE (E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2
    where f :: E -> E -> E
f E
a1 E
a2 = Name -> Spec1 -> [E] -> E
opcs Name
"lineto" [(Rate
Kr,[Rate
Kr,Rate
Kr])] [E
a1,E
a2]

-- | 
-- Applies portamento to a step-valued control signal.
--
-- > kres  port  ksig, ihtim [, isig]
--
-- csound doc: <http://csound.com/docs/manual/port.html>
port ::  Sig -> D -> Sig
port :: Sig -> D -> Sig
port Sig
b1 D
b2 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E
f (E -> E -> E) -> GE E -> GE (E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b2
    where f :: E -> E -> E
f E
a1 E
a2 = Name -> Spec1 -> [E] -> E
opcs Name
"port" [(Rate
Kr,[Rate
Kr,Rate
Ir,Rate
Ir])] [E
a1,E
a2]

-- | 
-- Applies portamento to a step-valued control signal.
--
-- > kres  portk  ksig, khtim [, isig]
--
-- csound doc: <http://csound.com/docs/manual/portk.html>
portk ::  Sig -> Sig -> Sig
portk :: Sig -> Sig -> Sig
portk Sig
b1 Sig
b2 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E
f (E -> E -> E) -> GE E -> GE (E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2
    where f :: E -> E -> E
f E
a1 E
a2 = Name -> Spec1 -> [E] -> E
opcs Name
"portk" [(Rate
Kr,[Rate
Kr,Rate
Kr,Rate
Ir])] [E
a1,E
a2]

-- | 
-- A second-order resonant filter.
--
-- > kres  resonk  ksig, kcf, kbw [, iscl] [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/resonk.html>
resonk ::  Sig -> Sig -> Sig -> Sig
resonk :: Sig -> Sig -> Sig -> Sig
resonk Sig
b1 Sig
b2 Sig
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"resonk" [(Rate
Kr,[Rate
Kr,Rate
Kr,Rate
Kr,Rate
Ir,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- Control signal resonant filter stack.
--
-- resonxk is equivalent to a group of resonk filters, with the same arguments, serially connected. Using a stack of a larger number of filters allows a sharper cutoff.
--
-- > kres  resonxk  ksig, kcf, kbw[, inumlayer, iscl, istor]
--
-- csound doc: <http://csound.com/docs/manual/resonxk.html>
resonxk ::  Sig -> Sig -> Sig -> Sig
resonxk :: Sig -> Sig -> Sig -> Sig
resonxk Sig
b1 Sig
b2 Sig
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"resonxk" [(Rate
Kr,[Rate
Kr,Rate
Kr,Rate
Kr,Rate
Ir,Rate
Ir,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- Exponential Lag
--
-- Exponential lag with 60dB lag time. Port of Supercollider's Lag
--
-- > aout  sc_lag  ain, klagtime [, initialvalue=0]
-- > kout  sc_lag  kin, klagtime [, initialvalue=0]
--
-- csound doc: <http://csound.com/docs/manual/sc_lag.html>
sc_lag ::  Sig -> Sig -> Sig
sc_lag :: Sig -> Sig -> Sig
sc_lag Sig
b1 Sig
b2 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E
f (E -> E -> E) -> GE E -> GE (E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2
    where f :: E -> E -> E
f E
a1 E
a2 = Name -> Spec1 -> [E] -> E
opcs Name
"sc_lag" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Ir]),(Rate
Kr,[Rate
Kr,Rate
Kr,Rate
Ir])] [E
a1,E
a2]

-- | 
-- Exponential Lag
--
-- Exponential lag with different smoothing time for up- and
-- 	  downgoing signals. Port of Supercollider's LagUD
--
-- > aout  sc_lagud  ain, klagup, klagdown
-- > kout  sc_lagud  kin, klagup, klagdown
--
-- csound doc: <http://csound.com/docs/manual/sc_lagud.html>
sc_lagud ::  Sig -> Sig -> Sig -> Sig
sc_lagud :: Sig -> Sig -> Sig -> Sig
sc_lagud Sig
b1 Sig
b2 Sig
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"sc_lagud" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Kr]),(Rate
Kr,[Rate
Kr,Rate
Kr,Rate
Kr])] [E
a1,E
a2,E
a3]

-- | 
-- Timed trigger
--
-- Timed trigger. Port of Supercollider's Trig ugen
--
-- > aout  sc_trig  ain, kdur
-- > kout  sc_trig  kin, kdur
--
-- csound doc: <http://csound.com/docs/manual/sc_trig.html>
sc_trig ::  Sig -> Sig -> Sig
sc_trig :: Sig -> Sig -> Sig
sc_trig Sig
b1 Sig
b2 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E
f (E -> E -> E) -> GE E -> GE (E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2
    where f :: E -> E -> E
f E
a1 E
a2 = Name -> Spec1 -> [E] -> E
opcs Name
"sc_trig" [(Rate
Ar,[Rate
Ar,Rate
Kr]),(Rate
Kr,[Rate
Kr,Rate
Kr])] [E
a1,E
a2]

-- | 
-- Generate glissandos starting from a control signal.
--
-- Generate glissandos starting from a control signal with a trigger.
--
-- > kres  tlineto  ksig, ktime, ktrig
--
-- csound doc: <http://csound.com/docs/manual/tlineto.html>
tlineto ::  Sig -> Sig -> Sig -> Sig
tlineto :: Sig -> Sig -> Sig -> Sig
tlineto Sig
b1 Sig
b2 Sig
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"tlineto" [(Rate
Kr,[Rate
Kr,Rate
Kr,Rate
Kr])] [E
a1,E
a2,E
a3]

-- | 
-- A first-order recursive low-pass filter with variable frequency response.
--
-- > kres  tonek  ksig, khp [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/tonek.html>
tonek ::  Sig -> Sig -> Sig
tonek :: Sig -> Sig -> Sig
tonek Sig
b1 Sig
b2 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E
f (E -> E -> E) -> GE E -> GE (E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2
    where f :: E -> E -> E
f E
a1 E
a2 = Name -> Spec1 -> [E] -> E
opcs Name
"tonek" [(Rate
Kr,[Rate
Kr,Rate
Kr,Rate
Ir])] [E
a1,E
a2]

-- Specialized Filters.

-- | 
-- A DC blocking filter.
--
-- Implements the DC blocking filter
--
-- > ares  dcblock  ain [, igain]
--
-- csound doc: <http://csound.com/docs/manual/dcblock.html>
dcblock ::  Sig -> Sig
dcblock :: Sig -> Sig
dcblock Sig
b1 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E
f (E -> E) -> GE E -> GE E
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1
    where f :: E -> E
f E
a1 = Name -> Spec1 -> [E] -> E
opcs Name
"dcblock" [(Rate
Ar,[Rate
Ar,Rate
Ir])] [E
a1]

-- | 
-- A DC blocking filter.
--
-- Implements a DC blocking filter with improved DC attenuation.
--
-- > ares  dcblock2  ain [, iorder] [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/dcblock2.html>
dcblock2 ::  Sig -> Sig
dcblock2 :: Sig -> Sig
dcblock2 Sig
b1 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E
f (E -> E) -> GE E -> GE E
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1
    where f :: E -> E
f E
a1 = Name -> Spec1 -> [E] -> E
opcs Name
"dcblock2" [(Rate
Ar,[Rate
Ar,Rate
Ir,Rate
Ir])] [E
a1]

-- | 
-- Equalizer filter
--
-- The opcode eqfil is a 2nd order tunable equalisation filter based on Regalia and Mitra
--       design ("Tunable Digital Frequency Response Equalization Filters", IEEE Trans.
--       on Ac., Sp. and Sig Proc., 35 (1), 1987). It provides a peak/notch filter for
--       building parametric/graphic equalisers.
--
-- > asig  eqfil  ain, kcf, kbw, kgain[, istor]
--
-- csound doc: <http://csound.com/docs/manual/eqfil.html>
eqfil ::  Sig -> Sig -> Sig -> Sig -> Sig
eqfil :: Sig -> Sig -> Sig -> Sig -> Sig
eqfil Sig
b1 Sig
b2 Sig
b3 Sig
b4 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E
f (E -> E -> E -> E -> E) -> GE E -> GE (E -> E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b4
    where f :: E -> E -> E -> E -> E
f E
a1 E
a2 E
a3 E
a4 = Name -> Spec1 -> [E] -> E
opcs Name
"eqfil" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Kr,Rate
Kr,Rate
Ir])] [E
a1,E
a2,E
a3,E
a4]

-- | 
-- Performs filtering using a transposed form-II digital filter lattice with no time-varying control.
--
-- General purpose custom filter with no time-varying pole control. The filter coefficients implement the following difference equation:
--
-- > ares  filter2  asig, iM, iN, ib0, ib1, ..., ibM, ia1, ia2, ..., iaN
-- > kres  filter2  ksig, iM, iN, ib0, ib1, ..., ibM, ia1, ia2, ..., iaN
--
-- csound doc: <http://csound.com/docs/manual/filter2.html>
filter2 ::  Sig -> D -> D -> [D] -> Sig
filter2 :: Sig -> D -> D -> [D] -> Sig
filter2 Sig
b1 D
b2 D
b3 [D]
b4 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> [E] -> E
f (E -> E -> E -> [E] -> E) -> GE E -> GE (E -> E -> [E] -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> [E] -> E) -> GE E -> GE (E -> [E] -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b2 GE (E -> [E] -> E) -> GE E -> GE ([E] -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b3 GE ([E] -> E) -> GE [E] -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (D -> GE E) -> [D] -> GE [E]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM D -> GE E
unD [D]
b4
    where f :: E -> E -> E -> [E] -> E
f E
a1 E
a2 E
a3 [E]
a4 = Name -> Spec1 -> [E] -> E
opcs Name
"filter2" [(Rate
Ar,[Rate
Ar] [Rate] -> [Rate] -> [Rate]
forall a. [a] -> [a] -> [a]
++ (Rate -> [Rate]
forall a. a -> [a]
repeat Rate
Ir)),(Rate
Kr,[Rate
Kr] [Rate] -> [Rate] -> [Rate]
forall a. [a] -> [a] -> [a]
++ (Rate -> [Rate]
forall a. a -> [a]
repeat Rate
Ir))] ([E
a1
                                                                                              ,E
a2
                                                                                              ,E
a3] [E] -> [E] -> [E]
forall a. [a] -> [a] -> [a]
++ [E]
a4)

-- | 
-- AM/FM analysis from quadrature signal.
--
-- This opcode attempts to extract the AM and FM signals off a
--       quadrature signal (e.g. from a Hilbert transform).
--
-- > am, af  fmanal  are, aim
--
-- csound doc: <http://csound.com/docs/manual/fmanal.html>
fmanal ::  Sig -> Sig -> (Sig,Sig)
fmanal :: Sig -> Sig -> (Sig, Sig)
fmanal Sig
b1 Sig
b2 = GE (MultiOut [E]) -> (Sig, Sig)
forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple (GE (MultiOut [E]) -> (Sig, Sig))
-> GE (MultiOut [E]) -> (Sig, Sig)
forall a b. (a -> b) -> a -> b
$ E -> E -> MultiOut [E]
f (E -> E -> MultiOut [E]) -> GE E -> GE (E -> MultiOut [E])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> MultiOut [E]) -> GE E -> GE (MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2
    where f :: E -> E -> MultiOut [E]
f E
a1 E
a2 = Name -> Specs -> [E] -> MultiOut [E]
mopcs Name
"fmanal" ([Rate
Ar,Rate
Ar],[Rate
Ar,Rate
Ar]) [E
a1,E
a2]

-- | 
-- Formant filter.
--
-- Fofilter generates a stream of overlapping sinewave grains, when fed with 
-- a pulse train. Each grain is the impulse response of a combination of 
-- two BP filters. The grains are defined by their attack time (determining 
-- the skirtwidth of the formant region at -60dB) and decay time 
-- (-6dB bandwidth). Overlapping will occur when 1/freq < decay, but, 
-- unlike FOF, there is no upper limit on the number of overlaps. 
-- The original idea for this opcode came from J McCartney's formlet class 
-- in SuperCollider, but this is possibly implemented differently(?).
--
-- > asig  fofilter  ain, xcf, xris, xdec[, istor]
--
-- csound doc: <http://csound.com/docs/manual/fofilter.html>
fofilter ::  Sig -> Sig -> Sig -> Sig -> Sig
fofilter :: Sig -> Sig -> Sig -> Sig -> Sig
fofilter Sig
b1 Sig
b2 Sig
b3 Sig
b4 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E
f (E -> E -> E -> E -> E) -> GE E -> GE (E -> E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b4
    where f :: E -> E -> E -> E -> E
f E
a1 E
a2 E
a3 E
a4 = Name -> Spec1 -> [E] -> E
opcs Name
"fofilter" [(Rate
Ar,[Rate
Ar,Rate
Xr,Rate
Xr,Rate
Xr,Rate
Ir])] [E
a1,E
a2,E
a3,E
a4]

-- | 
-- A Hilbert transformer.
--
-- An IIR implementation of a Hilbert transformer.
--
-- > ar1, ar2  hilbert  asig
--
-- csound doc: <http://csound.com/docs/manual/hilbert.html>
hilbert ::  Sig -> (Sig,Sig)
hilbert :: Sig -> (Sig, Sig)
hilbert Sig
b1 = GE (MultiOut [E]) -> (Sig, Sig)
forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple (GE (MultiOut [E]) -> (Sig, Sig))
-> GE (MultiOut [E]) -> (Sig, Sig)
forall a b. (a -> b) -> a -> b
$ E -> MultiOut [E]
f (E -> MultiOut [E]) -> GE E -> GE (MultiOut [E])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1
    where f :: E -> MultiOut [E]
f E
a1 = Name -> Specs -> [E] -> MultiOut [E]
mopcs Name
"hilbert" ([Rate
Ar,Rate
Ar],[Rate
Ar]) [E
a1]

-- | 
-- A Hilbert rransformer.
--
-- A DFT-based implementation of a Hilbert transformer.
--
-- > ar1, ar2  hilbert2  asig, ifftsize, ihopsize
--
-- csound doc: <http://csound.com/docs/manual/hilbert2.html>
hilbert2 ::  Sig -> D -> D -> (Sig,Sig)
hilbert2 :: Sig -> D -> D -> (Sig, Sig)
hilbert2 Sig
b1 D
b2 D
b3 = GE (MultiOut [E]) -> (Sig, Sig)
forall a. Tuple a => GE (MultiOut [E]) -> a
pureTuple (GE (MultiOut [E]) -> (Sig, Sig))
-> GE (MultiOut [E]) -> (Sig, Sig)
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> MultiOut [E]
f (E -> E -> E -> MultiOut [E])
-> GE E -> GE (E -> E -> MultiOut [E])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> MultiOut [E]) -> GE E -> GE (E -> MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b2 GE (E -> MultiOut [E]) -> GE E -> GE (MultiOut [E])
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b3
    where f :: E -> E -> E -> MultiOut [E]
f E
a1 E
a2 E
a3 = Name -> Specs -> [E] -> MultiOut [E]
mopcs Name
"hilbert2" ([Rate
Ar,Rate
Ar],[Rate
Ar,Rate
Ir,Rate
Ir]) [E
a1,E
a2,E
a3]

-- | 
-- A filter with a non-linear effect.
--
-- Implements the filter:
--
-- > ares  nlfilt  ain, ka, kb, kd, kC, kL
--
-- csound doc: <http://csound.com/docs/manual/nlfilt.html>
nlfilt ::  Sig -> Sig -> Sig -> Sig -> Sig -> Sig -> Sig
nlfilt :: Sig -> Sig -> Sig -> Sig -> Sig -> Sig -> Sig
nlfilt Sig
b1 Sig
b2 Sig
b3 Sig
b4 Sig
b5 Sig
b6 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E -> E -> E
f (E -> E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> E -> E -> E) -> GE E -> GE (E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b4 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b5 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b6
    where f :: E -> E -> E -> E -> E -> E -> E
f E
a1 E
a2 E
a3 E
a4 E
a5 E
a6 = Name -> Spec1 -> [E] -> E
opcs Name
"nlfilt" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Kr,Rate
Kr,Rate
Kr,Rate
Kr])] [E
a1,E
a2,E
a3,E
a4,E
a5,E
a6]

-- | 
-- A filter with a non-linear effect and blowup protection.
--
-- Implements the filter:
--
-- > ares  nlfilt2  ain, ka, kb, kd, kC, kL
--
-- csound doc: <http://csound.com/docs/manual/nlfilt2.html>
nlfilt2 ::  Sig -> Sig -> Sig -> Sig -> Sig -> Sig -> Sig
nlfilt2 :: Sig -> Sig -> Sig -> Sig -> Sig -> Sig -> Sig
nlfilt2 Sig
b1 Sig
b2 Sig
b3 Sig
b4 Sig
b5 Sig
b6 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E -> E -> E
f (E -> E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> E -> E -> E) -> GE E -> GE (E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b4 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b5 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b6
    where f :: E -> E -> E -> E -> E -> E -> E
f E
a1 E
a2 E
a3 E
a4 E
a5 E
a6 = Name -> Spec1 -> [E] -> E
opcs Name
"nlfilt2" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Kr,Rate
Kr,Rate
Kr,Rate
Kr])] [E
a1,E
a2,E
a3,E
a4,E
a5,E
a6]

-- | 
-- Implementation of Zoelzer's parametric equalizer filters.
--
-- Implementation of Zoelzer's parametric equalizer filters, with some modifications by the author.
--
-- > ares  pareq  asig, kc, kv, kq [, imode] [, iskip]
--
-- csound doc: <http://csound.com/docs/manual/pareq.html>
pareq ::  Sig -> Sig -> Sig -> Sig -> Sig
pareq :: Sig -> Sig -> Sig -> Sig -> Sig
pareq Sig
b1 Sig
b2 Sig
b3 Sig
b4 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E
f (E -> E -> E -> E -> E) -> GE E -> GE (E -> E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b4
    where f :: E -> E -> E -> E -> E
f E
a1 E
a2 E
a3 E
a4 = Name -> Spec1 -> [E] -> E
opcs Name
"pareq" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Kr,Rate
Kr,Rate
Ir,Rate
Ir])] [E
a1,E
a2,E
a3,E
a4]

-- | 
-- Parametric equalizer and filter opcode with 7 filter types, based
--       on algorithm by Robert Bristow-Johnson.
--
-- Parametric equalizer and filter opcode with 7 filter types,
--     	based on algorithm by Robert Bristow-Johnson.
--
-- > ar  rbjeq  asig, kfco, klvl, kQ, kS[, imode]
--
-- csound doc: <http://csound.com/docs/manual/rbjeq.html>
rbjeq ::  Sig -> Sig -> Sig -> Sig -> Sig -> Sig
rbjeq :: Sig -> Sig -> Sig -> Sig -> Sig -> Sig
rbjeq Sig
b1 Sig
b2 Sig
b3 Sig
b4 Sig
b5 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E -> E
f (E -> E -> E -> E -> E -> E) -> GE E -> GE (E -> E -> E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E -> E) -> GE E -> GE (E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b4 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b5
    where f :: E -> E -> E -> E -> E -> E
f E
a1 E
a2 E
a3 E
a4 E
a5 = Name -> Spec1 -> [E] -> E
opcs Name
"rbjeq" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Kr,Rate
Kr,Rate
Kr,Rate
Ir])] [E
a1,E
a2,E
a3,E
a4,E
a5]

-- | 
-- Performs filtering using a transposed form-II digital filter lattice with radial pole-shearing and angular pole-warping.
--
-- General purpose custom filter with time-varying pole control. The filter coefficients implement the following difference equation:
--
-- > ares  zfilter2  asig, kdamp, kfreq, iM, iN, ib0, ib1, ..., ibM, \
-- >           ia1,ia2, ..., iaN
--
-- csound doc: <http://csound.com/docs/manual/zfilter2.html>
zfilter2 ::  Sig -> Sig -> Sig -> D -> D -> [D] -> Sig
zfilter2 :: Sig -> Sig -> Sig -> D -> D -> [D] -> Sig
zfilter2 Sig
b1 Sig
b2 Sig
b3 D
b4 D
b5 [D]
b6 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E -> [E] -> E
f (E -> E -> E -> E -> E -> [E] -> E)
-> GE E -> GE (E -> E -> E -> E -> [E] -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E -> [E] -> E)
-> GE E -> GE (E -> E -> E -> [E] -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> E -> [E] -> E) -> GE E -> GE (E -> E -> [E] -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> E -> [E] -> E) -> GE E -> GE (E -> [E] -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b4 GE (E -> [E] -> E) -> GE E -> GE ([E] -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b5 GE ([E] -> E) -> GE [E] -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (D -> GE E) -> [D] -> GE [E]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM D -> GE E
unD [D]
b6
    where f :: E -> E -> E -> E -> E -> [E] -> E
f E
a1 E
a2 E
a3 E
a4 E
a5 [E]
a6 = Name -> Spec1 -> [E] -> E
opcs Name
"zfilter2" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Kr] [Rate] -> [Rate] -> [Rate]
forall a. [a] -> [a] -> [a]
++ (Rate -> [Rate]
forall a. a -> [a]
repeat Rate
Ir))] ([E
a1
                                                                                  ,E
a2
                                                                                  ,E
a3
                                                                                  ,E
a4
                                                                                  ,E
a5] [E] -> [E] -> [E]
forall a. [a] -> [a] -> [a]
++ [E]
a6)

-- Waveguides.

-- | 
-- A simple waveguide model consisting of one delay-line and one first-order lowpass filter.
--
-- > ares  wguide1  asig, xfreq, kcutoff, kfeedback
--
-- csound doc: <http://csound.com/docs/manual/wguide1.html>
wguide1 ::  Sig -> Sig -> Sig -> Sig -> Sig
wguide1 :: Sig -> Sig -> Sig -> Sig -> Sig
wguide1 Sig
b1 Sig
b2 Sig
b3 Sig
b4 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E
f (E -> E -> E -> E -> E) -> GE E -> GE (E -> E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b4
    where f :: E -> E -> E -> E -> E
f E
a1 E
a2 E
a3 E
a4 = Name -> Spec1 -> [E] -> E
opcs Name
"wguide1" [(Rate
Ar,[Rate
Ar,Rate
Xr,Rate
Kr,Rate
Kr])] [E
a1,E
a2,E
a3,E
a4]

-- | 
-- A model of beaten plate consisting of two parallel delay-lines and two first-order lowpass filters.
--
-- > ares  wguide2  asig, xfreq1, xfreq2, kcutoff1, kcutoff2, \
-- >           kfeedback1, kfeedback2
--
-- csound doc: <http://csound.com/docs/manual/wguide2.html>
wguide2 ::  Sig -> Sig -> Sig -> Sig -> Sig -> Sig -> Sig -> Sig
wguide2 :: Sig -> Sig -> Sig -> Sig -> Sig -> Sig -> Sig -> Sig
wguide2 Sig
b1 Sig
b2 Sig
b3 Sig
b4 Sig
b5 Sig
b6 Sig
b7 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E -> E -> E -> E -> E
f (E -> E -> E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E -> E -> E -> E -> E)
-> GE E -> GE (E -> E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3 GE (E -> E -> E -> E -> E) -> GE E -> GE (E -> E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b4 GE (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b5 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b6 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b7
    where f :: E -> E -> E -> E -> E -> E -> E -> E
f E
a1 E
a2 E
a3 E
a4 E
a5 E
a6 E
a7 = Name -> Spec1 -> [E] -> E
opcs Name
"wguide2" [(Rate
Ar,[Rate
Ar,Rate
Xr,Rate
Xr,Rate
Kr,Rate
Kr,Rate
Kr,Rate
Kr])] [E
a1
                                                                                ,E
a2
                                                                                ,E
a3
                                                                                ,E
a4
                                                                                ,E
a5
                                                                                ,E
a6
                                                                                ,E
a7]

-- Waveshaping.

-- | 
-- Efficiently evaluates the sum of Chebyshev polynomials of arbitrary order.
--
-- The chebyshevpoly opcode calculates the value of a polynomial expression with a single a-rate input variable that is made up of a linear combination of the first N Chebyshev polynomials of the first kind.  Each Chebyshev polynomial, Tn(x), is weighted by a k-rate coefficient, kn, so that the opcode is calculating a sum of any number of terms in the form kn*Tn(x).  Thus, the chebyshevpoly opcode allows for the waveshaping of an audio signal with a dynamic transfer function that gives precise control over the harmonic content of the output.
--
-- > aout  chebyshevpoly  ain, k0 [, k1 [, k2 [...]]]
--
-- csound doc: <http://csound.com/docs/manual/chebyshevpoly.html>
chebyshevpoly ::  Sig -> [Sig] -> Sig
chebyshevpoly :: Sig -> [Sig] -> Sig
chebyshevpoly Sig
b1 [Sig]
b2 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> [E] -> E
f (E -> [E] -> E) -> GE E -> GE ([E] -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE ([E] -> E) -> GE [E] -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Sig -> GE E) -> [Sig] -> GE [E]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM Sig -> GE E
unSig [Sig]
b2
    where f :: E -> [E] -> E
f E
a1 [E]
a2 = Name -> Spec1 -> [E] -> E
opcs Name
"chebyshevpoly" [(Rate
Ar,[Rate
Ar] [Rate] -> [Rate] -> [Rate]
forall a. [a] -> [a] -> [a]
++ (Rate -> [Rate]
forall a. a -> [a]
repeat Rate
Kr))] ([E
a1] [E] -> [E] -> [E]
forall a. [a] -> [a] -> [a]
++ [E]
a2)

-- | 
-- Performs linear clipping on an audio signal or a phasor.
--
-- The pdclip opcode allows a percentage of the input range of a signal to be clipped to fullscale. It is similar to simply multiplying the signal and limiting the range of the result, but pdclip allows you to think about how much of the signal range is being distorted instead of the scalar factor and has a offset parameter for assymetric clipping of the signal range. pdclip is also useful for remapping phasors for phase distortion synthesis.
--
-- > aout  pdclip  ain, kWidth, kCenter [, ibipolar [, ifullscale]]
--
-- csound doc: <http://csound.com/docs/manual/pdclip.html>
pdclip ::  Sig -> Sig -> Sig -> Sig
pdclip :: Sig -> Sig -> Sig -> Sig
pdclip Sig
b1 Sig
b2 Sig
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"pdclip" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Kr,Rate
Ir,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- Distorts a phasor for reading the two halves of a table at different rates.
--
-- The pdhalf opcode is designed to emulate the "classic" phase distortion synthesis method of the Casio CZ-series of synthesizers from the mid-1980's.  This technique reads the first and second halves of a function table at different rates in order to warp the waveform.  For example, pdhalf can smoothly transform a sine wave into something approximating the shape of a saw wave.
--
-- > aout  pdhalf  ain, kShapeAmount [, ibipolar [, ifullscale]]
--
-- csound doc: <http://csound.com/docs/manual/pdhalf.html>
pdhalf ::  Sig -> Sig -> Sig
pdhalf :: Sig -> Sig -> Sig
pdhalf Sig
b1 Sig
b2 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E
f (E -> E -> E) -> GE E -> GE (E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2
    where f :: E -> E -> E
f E
a1 E
a2 = Name -> Spec1 -> [E] -> E
opcs Name
"pdhalf" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Ir,Rate
Ir])] [E
a1,E
a2]

-- | 
-- Distorts a phasor for reading two unequal portions of a table in equal periods.
--
-- The pdhalfy opcode is a variation on the phase distortion synthesis method of the pdhalf opcode.  It is useful for distorting a phasor in order to read two unequal portions of a table in the same number of samples.
--
-- > aout  pdhalfy  ain, kShapeAmount [, ibipolar [, ifullscale]]
--
-- csound doc: <http://csound.com/docs/manual/pdhalfy.html>
pdhalfy ::  Sig -> Sig -> Sig
pdhalfy :: Sig -> Sig -> Sig
pdhalfy Sig
b1 Sig
b2 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E
f (E -> E -> E) -> GE E -> GE (E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2
    where f :: E -> E -> E
f E
a1 E
a2 = Name -> Spec1 -> [E] -> E
opcs Name
"pdhalfy" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Ir,Rate
Ir])] [E
a1,E
a2]

-- | 
-- Waveshapes a signal by raising it to a variable exponent.
--
-- The powershape opcode raises an input signal to a power with pre- and post-scaling of the signal so that the output will be in a predictable range.  It also processes negative inputs in a symmetrical way to positive inputs, calculating a dynamic transfer function that is useful for waveshaping.
--
-- > aout  powershape  ain, kShapeAmount [, ifullscale]
--
-- csound doc: <http://csound.com/docs/manual/powershape.html>
powershape ::  Sig -> Sig -> Sig
powershape :: Sig -> Sig -> Sig
powershape Sig
b1 Sig
b2 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E
f (E -> E -> E) -> GE E -> GE (E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2
    where f :: E -> E -> E
f E
a1 E
a2 = Name -> Spec1 -> [E] -> E
opcs Name
"powershape" [(Rate
Ar,[Rate
Ar,Rate
Kr,Rate
Ir])] [E
a1,E
a2]

-- Comparators and Accumulators.

-- | 
-- Compares two audio signals
--
-- Compares two audio signals using the standard math operators
--
-- > aout  cmp  aL, S_operator, aR
--
-- csound doc: <http://csound.com/docs/manual/cmp.html>
cmp ::  Sig -> Str -> Sig -> Sig
cmp :: Sig -> Str -> Sig -> Sig
cmp Sig
b1 Str
b2 Sig
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Str -> GE E
unStr Str
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"cmp" [(Rate
Ar,[Rate
Ar,Rate
Sr,Rate
Ar])] [E
a1,E
a2,E
a3]

-- | 
-- Produces a signal that is the maximum of any number of input signals.
--
-- The max opcode takes any number of a-rate,
--       k-rate or i-rate signals as input (all of the same rate), and outputs a signal at the same rate that is the maximum of all of the inputs.  For a-rate signals, the inputs are compared one sample at a time (i.e. max does not scan an entire ksmps period of a signal for its local maximum as the max_k opcode does).
--
-- > amax  max  ain1, ain2 [, ain3] [, ain4] [...]
-- > kmax  max  kin1, kin2 [, kin3] [, kin4] [...]
-- > imax  max  iin1, iin2 [, iin3] [, iin4] [...]
--
-- csound doc: <http://csound.com/docs/manual/max.html>
max' ::  [Sig] -> Sig
max' :: [Sig] -> Sig
max' [Sig]
b1 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ [E] -> E
f ([E] -> E) -> GE [E] -> GE E
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Sig -> GE E) -> [Sig] -> GE [E]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM Sig -> GE E
unSig [Sig]
b1
    where f :: [E] -> E
f [E]
a1 = Name -> Spec1 -> [E] -> E
opcs Name
"max" [(Rate
Ar,(Rate -> [Rate]
forall a. a -> [a]
repeat Rate
Ar)),(Rate
Kr,(Rate -> [Rate]
forall a. a -> [a]
repeat Rate
Kr)),(Rate
Ir,(Rate -> [Rate]
forall a. a -> [a]
repeat Rate
Ir))] [E]
a1

-- | 
-- Local maximum (or minimum) value of an incoming asig signal
--
-- max_k outputs the local maximum (or minimum) value of  the incoming asig signal, checked in the time interval between ktrig has become true twice.
--
-- > knumkout  max_k  asig, ktrig, itype
--
-- csound doc: <http://csound.com/docs/manual/max_k.html>
max_k ::  Sig -> Sig -> D -> Sig
max_k :: Sig -> Sig -> D -> Sig
max_k Sig
b1 Sig
b2 D
b3 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ E -> E -> E -> E
f (E -> E -> E -> E) -> GE E -> GE (E -> E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E -> E) -> GE E -> GE (E -> E)
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> D -> GE E
unD D
b3
    where f :: E -> E -> E -> E
f E
a1 E
a2 E
a3 = Name -> Spec1 -> [E] -> E
opcs Name
"max_k" [(Rate
Kr,[Rate
Ar,Rate
Kr,Rate
Ir])] [E
a1,E
a2,E
a3]

-- | 
-- Produces a signal that is the maximum of the absolute values of any number of input signals.
--
-- The maxabs opcode takes any number of a-rate or k-rate signals as input (all of the same rate), and outputs a signal at the same rate that is the maximum of all of the inputs.  It is identical to the max opcode except that it takes the absolute value of each input before comparing them.  Therefore, the output is always non-negative.  For a-rate signals, the inputs are compared one sample at a time (i.e. maxabs does not scan an entire ksmps period of a signal for its local maximum as the max_k opcode does).
--
-- > amax  maxabs  ain1, ain2 [, ain3] [, ain4] [...]
-- > kmax  maxabs  kin1, kin2 [, kin3] [, kin4] [...]
--
-- csound doc: <http://csound.com/docs/manual/maxabs.html>
maxabs ::  [Sig] -> Sig
maxabs :: [Sig] -> Sig
maxabs [Sig]
b1 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ [E] -> E
f ([E] -> E) -> GE [E] -> GE E
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Sig -> GE E) -> [Sig] -> GE [E]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM Sig -> GE E
unSig [Sig]
b1
    where f :: [E] -> E
f [E]
a1 = Name -> Spec1 -> [E] -> E
opcs Name
"maxabs" [(Rate
Ar,(Rate -> [Rate]
forall a. a -> [a]
repeat Rate
Ar)),(Rate
Kr,(Rate -> [Rate]
forall a. a -> [a]
repeat Rate
Kr))] [E]
a1

-- | 
-- Accumulates the maximum of the absolute values of audio signals.
--
-- maxabsaccum compares two audio-rate variables and stores the maximum of their absolute values into the first.
--
-- >  maxabsaccum  aAccumulator, aInput
--
-- csound doc: <http://csound.com/docs/manual/maxabsaccum.html>
maxabsaccum ::  Sig -> Sig -> SE ()
maxabsaccum :: Sig -> Sig -> SE ()
maxabsaccum Sig
b1 Sig
b2 = Dep () -> SE ()
forall a. Dep a -> SE a
SE (Dep () -> SE ()) -> Dep () -> SE ()
forall a b. (a -> b) -> a -> b
$ (E -> Dep ()
forall (m :: * -> *). Monad m => E -> DepT m ()
depT_ (E -> Dep ()) -> DepT GE E -> Dep ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<<) (DepT GE E -> Dep ()) -> DepT GE E -> Dep ()
forall a b. (a -> b) -> a -> b
$ GE E -> DepT GE E
forall (m :: * -> *) a. Monad m => m a -> DepT m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (GE E -> DepT GE E) -> GE E -> DepT GE E
forall a b. (a -> b) -> a -> b
$ E -> E -> E
f (E -> E -> E) -> GE E -> GE (E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2
    where f :: E -> E -> E
f E
a1 E
a2 = Name -> Spec1 -> [E] -> E
opcs Name
"maxabsaccum" [(Rate
Xr,[Rate
Ar,Rate
Ar])] [E
a1,E
a2]

-- | 
-- Accumulates the maximum value of audio signals.
--
-- maxaccum compares two audio-rate variables and stores the maximum value between them into the first.
--
-- >  maxaccum  aAccumulator, aInput
--
-- csound doc: <http://csound.com/docs/manual/maxaccum.html>
maxaccum ::  Sig -> Sig -> SE ()
maxaccum :: Sig -> Sig -> SE ()
maxaccum Sig
b1 Sig
b2 = Dep () -> SE ()
forall a. Dep a -> SE a
SE (Dep () -> SE ()) -> Dep () -> SE ()
forall a b. (a -> b) -> a -> b
$ (E -> Dep ()
forall (m :: * -> *). Monad m => E -> DepT m ()
depT_ (E -> Dep ()) -> DepT GE E -> Dep ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<<) (DepT GE E -> Dep ()) -> DepT GE E -> Dep ()
forall a b. (a -> b) -> a -> b
$ GE E -> DepT GE E
forall (m :: * -> *) a. Monad m => m a -> DepT m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (GE E -> DepT GE E) -> GE E -> DepT GE E
forall a b. (a -> b) -> a -> b
$ E -> E -> E
f (E -> E -> E) -> GE E -> GE (E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2
    where f :: E -> E -> E
f E
a1 E
a2 = Name -> Spec1 -> [E] -> E
opcs Name
"maxaccum" [(Rate
Xr,[Rate
Ar,Rate
Ar])] [E
a1,E
a2]

-- | 
-- Produces a signal that is the minimum of any number of input signals.
--
-- The min opcode takes any number of a-rate,
--       k-rate or i-rate signals as input (all of the same rate), and outputs a signal at the same rate that is the minimum of all of the inputs.  For a-rate signals, the inputs are compared one sample at a time (i.e. min does not scan an entire ksmps period of a signal for its local minimum as the max_k opcode does).
--
-- > amin  min  ain1, ain2 [, ain3] [, ain4] [...]
-- > kmin  min  kin1, kin2 [, kin3] [, kin4] [...]
-- > imin  min  iin1, iin2 [, iin3] [, iin4] [...]
--
-- csound doc: <http://csound.com/docs/manual/min.html>
min' ::  [Sig] -> Sig
min' :: [Sig] -> Sig
min' [Sig]
b1 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ [E] -> E
f ([E] -> E) -> GE [E] -> GE E
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Sig -> GE E) -> [Sig] -> GE [E]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM Sig -> GE E
unSig [Sig]
b1
    where f :: [E] -> E
f [E]
a1 = Name -> Spec1 -> [E] -> E
opcs Name
"min" [(Rate
Ar,(Rate -> [Rate]
forall a. a -> [a]
repeat Rate
Ar)),(Rate
Kr,(Rate -> [Rate]
forall a. a -> [a]
repeat Rate
Kr)),(Rate
Ir,(Rate -> [Rate]
forall a. a -> [a]
repeat Rate
Ir))] [E]
a1

-- | 
-- Produces a signal that is the minimum of the absolute values of any number of input signals.
--
-- The minabs opcode takes any number of a-rate or k-rate signals as input (all of the same rate), and outputs a signal at the same rate that is the minimum of all of the inputs.  It is identical to the min opcode except that it takes the absolute value of each input before comparing them.  Therefore, the output is always non-negative.    For a-rate signals, the inputs are compared one sample at a time (i.e. minabs does not scan an entire ksmps period of a signal for its local minimum as the max_k opcode does).
--
-- > amin  minabs  ain1, ain2 [, ain3] [, ain4] [...]
-- > kmin  minabs  kin1, kin2 [, kin3] [, kin4] [...]
--
-- csound doc: <http://csound.com/docs/manual/minabs.html>
minabs ::  [Sig] -> Sig
minabs :: [Sig] -> Sig
minabs [Sig]
b1 = GE E -> Sig
Sig (GE E -> Sig) -> GE E -> Sig
forall a b. (a -> b) -> a -> b
$ [E] -> E
f ([E] -> E) -> GE [E] -> GE E
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Sig -> GE E) -> [Sig] -> GE [E]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM Sig -> GE E
unSig [Sig]
b1
    where f :: [E] -> E
f [E]
a1 = Name -> Spec1 -> [E] -> E
opcs Name
"minabs" [(Rate
Ar,(Rate -> [Rate]
forall a. a -> [a]
repeat Rate
Ar)),(Rate
Kr,(Rate -> [Rate]
forall a. a -> [a]
repeat Rate
Kr))] [E]
a1

-- | 
-- Accumulates the minimum of the absolute values of audio signals.
--
-- minabsaccum compares two audio-rate variables and stores the minimum of their absolute values into the first.
--
-- >  minabsaccum  aAccumulator, aInput
--
-- csound doc: <http://csound.com/docs/manual/minabsaccum.html>
minabsaccum ::  Sig -> Sig -> SE ()
minabsaccum :: Sig -> Sig -> SE ()
minabsaccum Sig
b1 Sig
b2 = Dep () -> SE ()
forall a. Dep a -> SE a
SE (Dep () -> SE ()) -> Dep () -> SE ()
forall a b. (a -> b) -> a -> b
$ (E -> Dep ()
forall (m :: * -> *). Monad m => E -> DepT m ()
depT_ (E -> Dep ()) -> DepT GE E -> Dep ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<<) (DepT GE E -> Dep ()) -> DepT GE E -> Dep ()
forall a b. (a -> b) -> a -> b
$ GE E -> DepT GE E
forall (m :: * -> *) a. Monad m => m a -> DepT m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (GE E -> DepT GE E) -> GE E -> DepT GE E
forall a b. (a -> b) -> a -> b
$ E -> E -> E
f (E -> E -> E) -> GE E -> GE (E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2
    where f :: E -> E -> E
f E
a1 E
a2 = Name -> Spec1 -> [E] -> E
opcs Name
"minabsaccum" [(Rate
Xr,[Rate
Ar,Rate
Ar])] [E
a1,E
a2]

-- | 
-- Accumulates the minimum value of audio signals.
--
-- minaccum compares two audio-rate variables and stores the minimum value between them into the first.
--
-- >  minaccum  aAccumulator, aInput
--
-- csound doc: <http://csound.com/docs/manual/minaccum.html>
minaccum ::  Sig -> Sig -> SE ()
minaccum :: Sig -> Sig -> SE ()
minaccum Sig
b1 Sig
b2 = Dep () -> SE ()
forall a. Dep a -> SE a
SE (Dep () -> SE ()) -> Dep () -> SE ()
forall a b. (a -> b) -> a -> b
$ (E -> Dep ()
forall (m :: * -> *). Monad m => E -> DepT m ()
depT_ (E -> Dep ()) -> DepT GE E -> Dep ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<<) (DepT GE E -> Dep ()) -> DepT GE E -> Dep ()
forall a b. (a -> b) -> a -> b
$ GE E -> DepT GE E
forall (m :: * -> *) a. Monad m => m a -> DepT m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (GE E -> DepT GE E) -> GE E -> DepT GE E
forall a b. (a -> b) -> a -> b
$ E -> E -> E
f (E -> E -> E) -> GE E -> GE (E -> E)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sig -> GE E
unSig Sig
b1 GE (E -> E) -> GE E -> GE E
forall a b. GE (a -> b) -> GE a -> GE b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sig -> GE E
unSig Sig
b2
    where f :: E -> E -> E
f E
a1 E
a2 = Name -> Spec1 -> [E] -> E
opcs Name
"minaccum" [(Rate
Xr,[Rate
Ar,Rate
Ar])] [E
a1,E
a2]