           for control rate"
     :auto-rate true}
 
+
    {:name "RLPF"
     :summary "resonant low pass filter"
-    :args [{:name "in", :default 0.0 :doc "input signal to be processed"}
-           {:name "freq", :default 440.0 :doc "cutoff frequency"}
-           {:name "rq", :default 1.0 :doc "the reciprocal of Q.  bandwidth / cutoffFreq. A lower rq results in more resonance."}]
+    :args [{:name "in"
+            :default 0.0
+            :doc "input signal to be processed"}
+
+           {:name "freq"
+            :default 440.0
+            :doc "cutoff frequency"}
+
+           {:name "rq"
+            :default 1.0
+            :doc "the reciprocal of Q.  bandwidth / cutoffFreq. A lower
+                  rq results in more resonance." }]
     :check (nth-input-stream? 0)
     :doc "A resonant low pass filter is a standard subtractive synthesis
           tool which removes frequencies above a defined cut-off

(def muladd-specs
  [
   {:name "Resonz",
    :args [{:name "in", :default 0.0 :doc "input signal to be processed"}
           {:name "freq", :default 440.0 :doc "resonant frequency in Hertz"}
           {:name "bwr", :default 1.0 :doc "bandwidth ratio (reciprocal of Q). rq = bandwidth / centerFreq"}]
    :check (nth-input-stream? 0)
    :doc "A Note on Constant-Gain Digital Resonators,\" Computer Music Journal, vol 18, no. 4, pp. 8-10, Winter 1994.\" Computer Music Journal, vol 18, no. 4, pp. 8-10, Winter 1994."
    :auto-rate true}

   {:name "OnePole",
    :args [{:name "in", :default 0.0 :doc "input signal to be processed"}
           {:name "coef", :default 0.5 :doc "feedback coefficient. Should be between -1 and +1"}]
    :check (nth-input-stream? 0)
    :doc "A one pole filter. Implements the formula:
out(i) = ((1 - abs(coef)) * in(i)) + (coef * out(i-1))"
    :auto-rate true}

   {:name "OneZero",
    :args [{:name "in", :default 0.0 :doc "input signal to be processed"}
           {:name "coef", :default 0.5 :doc "feed forward coefficient. +0.5 makes a two point averaging filter (see also lpz1), -0.5 makes a differentiator (see also hpz1), +1 makes a single sample delay (see also delay1), -1 makes an inverted single sample delay."}]
    :check (nth-input-stream? 0)
    :doc "A one zero filter. Implements the formula :
out(i) = ((1 - abs(coef)) * in(i)) + (coef * in(i-1))"
    :auto-rate true}

   {:name "TwoPole",
    :args [{:name "in", :default 0.0 :doc "input signal to be processed"}
           {:name "freq", :default 440.0 :doc "frequency of pole angle"}
           {:name "radius", :default 0.8 :doc "radius of pole. Should be between 0 and +1"}]
    :check (nth-input-stream? 0)
    :doc "a two pole filter. This provides lower level access to setting of pole location. For general purposes Resonz is better."
    :auto-rate true}

   {:name "TwoZero",
    :args [{:name "in", :default 0.0 :doc "input signal to be processed"}
           {:name "freq", :default 440.0 :doc "frequency of zero angle"}
           {:name "radius", :default 0.8 :doc "radios of zero"}]
    :check (nth-input-stream? 0)
    :doc "a two zero filter"
    :auto-rate true}

   {:name "APF",
    :args [{:name "in", :default 0.0}
           {:name "freq", :default 440.0}
           {:name "radius", :default 0.8}]
    :check (nth-input-stream? 0)
    :doc ""
    :auto-rate true}

   {:name "Integrator",
    :args [{:name "in", :default 0.0 :doc "input signal"}
           {:name "coef", :default 1.0 :doc "leak coefficient"}]
    :check (nth-input-stream? 0)
    :doc "leaky integrator. Integrates an input signal with a leak. The formula implemented is: out(0) = in(0) + (coef * out(-1))"
    :auto-rate true}

   {:name "Decay",
    :args [{:name "in", :default 0.0 :doc "input signal"}
           {:name "decay-time", :default 1.0 :doc "60 dB decay time in seconds"}]
    :check (nth-input-stream? 0)
    :doc "triggered exponential decay. This is essentially the same as integrator except that instead of supplying the coefficient directly, it is calculated from a 60 dB decay time. This is the time required for the integrator to lose 99.9 % of its value or -60dB. This is useful for exponential decaying envelopes triggered by impulses."
    :auto-rate true}

   {:name "Decay2",
    :args [{:name "in", :default 0.0 :doc "input signal"}
           {:name "attack-time", :default 0.01 :doc "60 dB attack time in seconds."}
           {:name "decay-time", :default 1.0 :doc "60 dB decay time in seconds."}]
    :check (nth-input-stream? 0)
    :doc "triggered exponential attack and exponential decay. Decay has a very sharp attack and can produce clicks. Decay2 rounds off the attack by subtracting one Decay from another. (decay in attack-time decay-time) equivalent to: (- (decay in attack-time decay-time) (decay in attack-time decay-time))"
    :auto-rate true}

   {:name "Lag",
    :args [{:name "in", :default 0.0 :doc "input signal"}
           {:name "lag-time", :default 0.1 :doc "60 dB lag time in seconds"}]
    :check (nth-input-stream? 0)
    :doc "exponential lag, useful for smoothing out control signals. This is essentially the same as OnePole except that instead of supplying the coefficient directly, it is calculated from a 60 dB lag time. This is the time required for the filter to converge to within 0.01 % of a value."
    :auto-rate true}

   {:name "Lag2",
    :args [{:name "in", :default 0.0 :doc "input signal"}
           {:name "lag-time", :default 0.1 :doc "60 dB lag time in seconds"} ]
    :check (nth-input-stream? 0)
    :doc "equivalent to Lag.kr(Lag.kr(in, time), time), resulting in a smoother transition. This saves on CPU as you only have to calculate the decay factor once instead of twice. See Lag for more details."
    :auto-rate true}

   {:name "Lag3",
    :args [{:name "in", :default 0.0 :doc "input signal"}
           {:name "lag-time", :default 0.1 :doc "60 dB lag time in seconds"}]
    :check (nth-input-stream? 0)
    :doc "Lag3 is equivalent to Lag.kr(Lag.kr(Lag.kr(in, time), time), time), thus resulting in a smoother transition. This saves on CPU as you only have to calculate the decay factor once instead of three times. See Lag for more details."
    :auto-rate true}

   {:name "Ramp",
    :args [{:name "in", :default 0.0 :doc "input signal"}
           {:name "lag-time", :default 0.1 :doc "60 dB lag time in seconds"}]
    :check (nth-input-stream? 0)
    :doc "similar to Lag but with a linear rather than exponential lag, useful for smoothing out control signals"
    :auto-rate true}

   {:name "LagUD",
    :args [{:name "in", :default 0.0 :doc "input signal"}
           {:name "lag-time-up", :default 0.1 :doc "60 dB lag time in seconds for the upgoing signal"}
           {:name "lag-time-down", :default 0.1 :doc "60 dB lag time in seconds for the downgoing signal"}]
    :check (nth-input-stream? 0)
    :doc "the same as Lag except that you can supply a different 60 dB time for when the signal goes up, from when the signal goes down"
    :auto-rate true}

   {:name "Lag2UD",
    :args [{:name "in", :default 0.0 :doc "input signal"}
           {:name "lag-time-up", :default 0.1 :doc "60 dB lag time in seconds for the upgoing signal"}
           {:name "lag-time-down", :default 0.1 :doc "60 dB lag time in seconds for the downgoing signal"}]
    :check (nth-input-stream? 0)
    :doc "Lag2 is equivalent to Lag.kr(Lag.kr(in, time), time)"
    :auto-rate true}

   {:name "Lag3UD",
    :args [{:name "in", :default 0.0 :doc "input signal"}
           {:name "lag-time-up", :default 0.1 :doc "60 dB lag time in seconds for the upgoing signal"}
           {:name "lag-time-down", :default 0.1 :doc "60 dB lag time in seconds for the downgoing signal"}]
    :check (nth-input-stream? 0)
    :doc "Lag3UD is equivalent to LagUD.kr(LagUD.kr(LagUD.kr(in, timeU, timeD), timeU, timeD), timeU, timeD)"
    :auto-rate true}

   {:name "LeakDC",
    :args [{:name "in", :default 0.0 :doc "input signal"}
           {:name "coef", :default 0.995
            :doc "leak coefficient. A value of 1 indicates no leakage
                 and 0 indicates high leakage - essentially the rate at
                 which the offset will return back to 0"}]
    :check (nth-input-stream? 0)
    :doc "removes a DC offset from signal. For example, a square wave
          contains prolonged sections of the cycle which are at +1 and

          real time thus creating movement in the sound."
    :auto-rate true}


   {:name "RHPF"
    :summary "resonant high pass filter"
    :args [{:name "in"
            :default 0.0
            :doc "input signal to be processed"}

           {:name "freq"
            :default 440.0
            :doc "cutoff frequency"}

           {:name "rq"
            :default 1.0
            :doc "the reciprocal of Q.  bandwidth / cutoffFreq. A lower
                  rq results in more resonance"}]
    :check (nth-input-stream? 0)

    :doc "A resonant high pass filter lets through the frequencies above
          the cutoff point and successfily dampens the frequencies below
          the cutoff point. This effectively removes the fundamental
