lazy_filters
Module¶
Stream filtering module
Summary of module contents:
Name  Description 

LinearFilterProperties  Class with common properties in a linear filter that can be used as a mixin. 
LinearFilter  Base class for Linear filters, time invariant or not. 
ZFilterMeta  <class 'audiolazy.lazy_filters.ZFilterMeta'> 
ZFilter  Linear filters based on Ztransform frequency domain equations. 
z  Linear filters based on Ztransform frequency domain equations. 
FilterListMeta  <class 'audiolazy.lazy_filters.FilterListMeta'> 
FilterList  Class from which CascadeFilter and ParallelFilter inherits the common part of their contents. You probably won’t need to use this directly. 
CascadeFilter  Filter cascade as a list of filters. 
ParallelFilter  Filters in parallel as a list of filters. 
comb  This is a StrategyDict instance object called comb .
Strategies stored: 3. 
resonator  This is a StrategyDict instance object called
resonator . Strategies stored: 4. 
lowpass  This is a StrategyDict instance object called
lowpass . Strategies stored: 4. 
highpass  This is a StrategyDict instance object called
highpass . Strategies stored: 4. 

class
LinearFilterProperties
[source]¶ Bases:
object
Class with common properties in a linear filter that can be used as a mixin.
The classes that inherits this one should implement the
numpoly
anddenpoly
properties, and these should return a Poly instance.
dendict
¶

denlist
¶

denominator
¶

denpolyz
¶ Like denpoly, the linear filter denominator (or backward coefficients) as a Poly instance based on
x = z
instead of denpoly’sx = z ** 1
, useful for taking roots.

numdict
¶

numerator
¶

numlist
¶

numpolyz
¶ Like numpoly, the linear filter numerator (or forward coefficients) as a Poly instance based on
x = z
instead of numpoly’sx = z ** 1
, useful for taking roots.


class
LinearFilter
(numerator=None, denominator=None)[source]¶ Bases:
audiolazy.lazy_filters.LinearFilterProperties
Base class for Linear filters, time invariant or not.

__call__
(seq, memory=None, zero=0.0)[source]¶ IIR, FIR and time variant linear filtering.
Parameters:  seq – Any iterable to be seem as the input stream for the filter.
 memory – Might be an iterable or a callable. Generally, as a iterable, the first needed elements from this input will be used directly as the memory (not the last ones!), and as a callable, it will be called with the size as the only positional argument, and should return an iterable. If
None
(default), memory is initialized with zeros.  zero – Value to fill the memory, when needed, and to be seem as previous input when there’s a delay. Defaults to
0.0
.
Returns: A Stream that have the data from the input sequence filtered.

copy
()[source]¶ Returns a filter copy.
It’ll return a LinearFilter instance (more specific class when subclassing) with the same terms in both numerator and denominator, but as a “T” (tee) copy when the coefficients are Stream instances, allowing maths using a filter more than once.

freq_response
(freq)[source]¶ Frequency response for this filter.
Parameters: freq – Frequency, in rad/sample. Can be an iterable with frequencies. Returns: Complex number with the frequency response of the filter. See also
dB10
 Logarithmic power magnitude from data with squared magnitude.
dB20
 Logarithmic power magnitude from raw complex data or data with linear amplitude.
phase
 Phase from complex data.
LinearFilter.plot
 Method to plot the LTI filter frequency and phase response into a Matplotlib figure.

is_causal
()[source]¶ Causality test for this filter.
Returns: Boolean returning True if this filter is causal, False otherwise.

is_lti
()[source]¶ Test if this filter is LTI (Linear Time Invariant).
Returns: Boolean returning True if this filter is LTI, False otherwise.

linearize
()[source]¶ Linear interpolation of fractional delay values.
Returns: A new linear filter, with the linearized delay values.  Examples:
>>> filt = z ** 4.3 >>> filt.linearize() 0.7 * z^4 + 0.3 * z^5

plot
(fig=None, samples=2048, rate=None, min_freq=0.0, max_freq=3.141592653589793, blk=None, unwrap=True, freq_scale='linear', mag_scale='dB')[source]¶ Plots the filter frequency response into a formatted MatPlotLib figure with two subplots, labels and title, including the magnitude response and the phase response.
Parameters:  fig – A matplotlib.figure.Figure instance. Defaults to None, which means that it will create a new figure.
 samples – Number of samples (frequency values) to plot. Defaults to 2048.
 rate – Given rate (samples/second) or “s” object from
sHz
. Defaults to 300.  [min_freq – ...
 max_freq] – Frequency range to be drawn, in rad/sample. Defaults to [0, pi].
 blk – Sequence block. Plots the block DFT together with the filter frequency. Defaults to None (no block).
 unwrap – Boolean that chooses whether should unwrap the data phase or keep it as is. Defaults to True.
 freq_scale – Chooses whether plot is “linear” or “log” with respect to the frequency axis. Defaults to “linear”. Case insensitive.
 mag_scale – Chooses whether magnitude plot scale should be “linear”, “squared” or “dB”. Defaults do “dB”. Case insensitive.
Returns: The matplotlib.figure.Figure instance.
See also
sHz
 Second and hertz constants from samples/second rate.
LinearFilter.zplot
 Zerospoles diagram plotting.
dB20
 Elementwise casting from an amplitude value to a logarithmic power gain (in decibels).
phase
 Phase from complex data.
LinearFilter.freq_response
 Get the complex frequency response of a filter for specific frequency values.
LinearFilter.zplot
 Filter zeropole plane plot.

poles
¶ Returns a list with all poles (denominator roots in
z
). Needs Numpy.See also
LinearFilterProperties.numpoly
 Numerator polynomials where x is
z ** 1
. LinearFilterProperties.denpoly
 Denominator polynomials where x is
z ** 1
. LinearFilterProperties.numpolyz
 Numerator polynomials where x is
z
. LinearFilterProperties.denpolyz
 Denominator polynomials where x is
z
.

zeros
¶ Returns a list with all zeros (numerator roots in
z
), besides the zerovalued “zeros” that might arise from the difference between the numerator and denominator order (i.e., the roots returned are the inverse from thenumpoly.roots()
inz ** 1
). Needs Numpy.See also
LinearFilterProperties.numpoly
 Numerator polynomials where x is
z ** 1
. LinearFilterProperties.denpoly
 Denominator polynomials where x is
z ** 1
. LinearFilterProperties.numpolyz
 Numerator polynomials where x is
z
. LinearFilterProperties.denpolyz
 Denominator polynomials where x is
z
.

zplot
(fig=None, circle=True)[source]¶ Plots the filter zeropole plane into a formatted MatPlotLib figure with one subplot, labels and title.
Parameters:  fig – A matplotlib.figure.Figure instance. Defaults to None, which means that it will create a new figure.
 circle – Chooses whether to include the unit circle in the plot. Defaults to True.
Returns: The matplotlib.figure.Figure instance.
Note
Multiple roots detection is slow, and roots may suffer from numerical errors (e.g., filter
f = 1  2 * z ** 1 + 1 * z ** 2
has twice the root1
, butf ** 3
suffer noise from the root finding algorithm). For the exact number of poles and zeros, see the result title, or the length of LinearFilter.poles() and LinearFilter.zeros().See also
LinearFilter.plot
 Frequency response plotting. Needs MatPlotLib.
LinearFilter.zeros
,LinearFilter.poles
 Filter zeros and poles, as a list. Needs NumPy.


class
ZFilterMeta
[source]¶ Bases:
audiolazy.lazy_core.AbstractOperatorOverloaderMeta

__operators__
= '+  * / **'¶


class
ZFilter
(numerator=None, denominator=None)[source]¶ Bases:
audiolazy.lazy_filters.LinearFilter
Linear filters based on Ztransform frequency domain equations.
 Examples:
Using the
z
object (float output because default filter memory has float zeros, and the delay in the numerator creates another float zero as “preinput”):>>> filt = (1 + z ** 1) / (1  z ** 1) >>> data = [1, 5, 4, 7, 9] >>> stream_result = filt(data) # Lazy iterable >>> list(stream_result) # Freeze [1.0, 7.0, 8.0, 3.0, 1.0]
Same example with the same filter, but with a memory input, and using lists for filter numerator and denominator instead of the
z
object:>>> b = [1, 1] >>> a = [1, 1] # Each index ``i`` has the coefficient for z ** i >>> filt = ZFilter(b, a) >>> data = [1, 5, 4, 7, 9] >>> stream_result = filt(data, memory=[3], zero=0) # Lazy iterable >>> result = list(stream_result) # Freeze >>> result [4, 10, 11, 0, 2] >>> filt2 = filt * z ** 1 # You can add a delay afterwards easily >>> final_result = filt2(result, zero=0) >>> list(final_result) [0, 4, 18, 39, 50]

__call__
(seq, memory=None, zero=0.0)[source]¶ IIR, FIR and time variant linear filtering.
Parameters:  seq – Any iterable to be seem as the input stream for the filter, or another ZFilter for substituition.
 memory – Might be an iterable or a callable. Generally, as a iterable, the first needed elements from this input will be used directly as the memory (not the last ones!), and as a callable, it will be called with the size as the only positional argument, and should return an iterable. If
None
(default), memory is initialized with zeros. Neglect whenseq
input is a ZFilter.  zero – Value to fill the memory, when needed, and to be seem as previous input when there’s a delay. Defaults to
0.0
. Neglect whenseq
input is a ZFilter.
Returns: A Stream that have the data from the input sequence filtered.
 Examples:
With ZFilter instances:
>>> filt = 1 + z ** 1 >>> filt(z ** 1) z + 1 >>> filt( z ** 2) 1  z^2
With any iterable (but ZFilter instances):
>>> filt = 1 + z ** 1 >>> data = filt([1.0, 2.0, 3.0]) >>> data <audiolazy.lazy_stream.Stream object at ...> >>> list(data) [1.0, 3.0, 5.0]

__neg__
()¶

__pos__
()¶

__radd__
(other)¶

__repr__
()¶

__rmul__
(other)¶

__rpow__
(other)¶

__rsub__
(other)¶

__rtruediv__
(other)¶

class
FilterListMeta
[source]¶ Bases:
audiolazy.lazy_core.AbstractOperatorOverloaderMeta

__operators__
= 'add * > >= < <='¶

__rbinary__
(op)¶


class
FilterList
(*filters)[source]¶ Bases:
list
,audiolazy.lazy_filters.LinearFilterProperties
Class from which CascadeFilter and ParallelFilter inherits the common part of their contents. You probably won’t need to use this directly.

__add__
(other)¶ This operator acts just like it would do with lists.

__ge__
(other)¶ This operator acts just like it would do with lists.

__gt__
(other)¶ This operator acts just like it would do with lists.

__hash__
= None¶

__le__
(other)¶ This operator acts just like it would do with lists.

__lt__
(other)¶ This operator acts just like it would do with lists.

__mul__
(other)¶ This operator acts just like it would do with lists.

__rmul__
(other)¶ This operator acts just like it would do with lists.

callables
¶ List of callables with all filters, casting to LinearFilter each one that isn’t callable.

is_causal
()[source]¶ Tests whether all filters in the list are causal (i.e., no futuredata delay in positive
z
exponents). Nonlinear filters are seem as causal by default. CascadeFilter and ParallelFilter are causal if all the filters they group are causal.

is_linear
()[source]¶ Tests whether all filters in the list are linear. CascadeFilter and ParallelFilter instances are also linear if all filters they group are linear.

is_lti
()[source]¶ Tests whether all filters in the list are linear time invariant (LTI). CascadeFilter and ParallelFilter instances are also LTI if all filters they group are LTI.

plot
(fig=None, samples=2048, rate=None, min_freq=0.0, max_freq=3.141592653589793, blk=None, unwrap=True, freq_scale='linear', mag_scale='dB')¶ Plots the filter frequency response into a formatted MatPlotLib figure with two subplots, labels and title, including the magnitude response and the phase response.
Parameters:  fig – A matplotlib.figure.Figure instance. Defaults to None, which means that it will create a new figure.
 samples – Number of samples (frequency values) to plot. Defaults to 2048.
 rate – Given rate (samples/second) or “s” object from
sHz
. Defaults to 300.  [min_freq – ...
 max_freq] – Frequency range to be drawn, in rad/sample. Defaults to [0, pi].
 blk – Sequence block. Plots the block DFT together with the filter frequency. Defaults to None (no block).
 unwrap – Boolean that chooses whether should unwrap the data phase or keep it as is. Defaults to True.
 freq_scale – Chooses whether plot is “linear” or “log” with respect to the frequency axis. Defaults to “linear”. Case insensitive.
 mag_scale – Chooses whether magnitude plot scale should be “linear”, “squared” or “dB”. Defaults do “dB”. Case insensitive.
Returns: The matplotlib.figure.Figure instance.
See also
sHz
 Second and hertz constants from samples/second rate.
LinearFilter.zplot
 Zerospoles diagram plotting.
dB20
 Elementwise casting from an amplitude value to a logarithmic power gain (in decibels).
phase
 Phase from complex data.
LinearFilter.freq_response
 Get the complex frequency response of a filter for specific frequency values.
LinearFilter.zplot
 Filter zeropole plane plot.

zplot
(fig=None, circle=True)¶ Plots the filter zeropole plane into a formatted MatPlotLib figure with one subplot, labels and title.
Parameters:  fig – A matplotlib.figure.Figure instance. Defaults to None, which means that it will create a new figure.
 circle – Chooses whether to include the unit circle in the plot. Defaults to True.
Returns: The matplotlib.figure.Figure instance.
Note
Multiple roots detection is slow, and roots may suffer from numerical errors (e.g., filter
f = 1  2 * z ** 1 + 1 * z ** 2
has twice the root1
, butf ** 3
suffer noise from the root finding algorithm). For the exact number of poles and zeros, see the result title, or the length of LinearFilter.poles() and LinearFilter.zeros().See also
LinearFilter.plot
 Frequency response plotting. Needs MatPlotLib.
LinearFilter.zeros
,LinearFilter.poles
 Filter zeros and poles, as a list. Needs NumPy.


class
CascadeFilter
(*filters)[source]¶ Bases:
audiolazy.lazy_filters.FilterList
Filter cascade as a list of filters.
Note
A filter is any callable that receives an iterable as input and returns a Stream.
 Examples:
>>> filt = CascadeFilter(z ** 1, 2 * (1  z ** 3)) >>> data = Stream(1, 3, 5, 3, 1, 1, 3, 5, 3, 1) # Endless >>> filt(data, zero=0).take(15) [0, 2, 6, 10, 4, 4, 12, 12, 12, 4, 4, 12, 12, 12, 4]

__add__
(other)¶ This operator acts just like it would do with lists.

__ge__
(other)¶ This operator acts just like it would do with lists.

__gt__
(other)¶ This operator acts just like it would do with lists.

__le__
(other)¶ This operator acts just like it would do with lists.

__lt__
(other)¶ This operator acts just like it would do with lists.

__mul__
(other)¶ This operator acts just like it would do with lists.

__rmul__
(other)¶ This operator acts just like it would do with lists.

denpoly
¶

numpoly
¶

poles
¶

zeros
¶

class
ParallelFilter
(*filters)[source]¶ Bases:
audiolazy.lazy_filters.FilterList
Filters in parallel as a list of filters.
This list of filters that behaves as a filter, returning the sum of all signals that results from applying the the same given input into all filters. Besides the name, the data processing done isn’t parallel.
Note
A filter is any callable that receives an iterable as input and returns a Stream.
 Examples:
>>> filt = 1 + z ** 1  z ** 2 >>> pfilt = ParallelFilter(1 + z ** 1,  z ** 2) >>> list(filt(range(100))) == list(pfilt(range(100))) True >>> list(filt(range(10), zero=0)) [0, 1, 3, 4, 5, 6, 7, 8, 9, 10]

__add__
(other)¶ This operator acts just like it would do with lists.

__ge__
(other)¶ This operator acts just like it would do with lists.

__gt__
(other)¶ This operator acts just like it would do with lists.

__le__
(other)¶ This operator acts just like it would do with lists.

__lt__
(other)¶ This operator acts just like it would do with lists.

__mul__
(other)¶ This operator acts just like it would do with lists.

__rmul__
(other)¶ This operator acts just like it would do with lists.

denpoly
¶

numpoly
¶

poles
¶

zeros
¶
lazy_filters.comb
StrategyDict¶
This is a StrategyDict instance object called
comb
. Strategies stored: 3.
Strategy comb.fb (Default).
Aliases available are comb.alpha
, comb.fb_alpha
, comb.feedback_alpha
.
Docstring starts with:
Feedback comb filter for a given alpha and delay.
Strategy comb.ff.
Aliases available are comb.ff_alpha
, comb.feedforward_alpha
.
Docstring starts with:
Feedforward comb filter for a given alpha (and delay).
Strategy comb.tau.
Aliases available are comb.fb_tau
, comb.feedback_tau
.
Docstring starts with:
Feedback comb filter for a given time constant (and delay).
Note
This docstring is selfgenerated, see the StrategyDict class and the strategies docs for more details.

tau
(delay, tau=inf)¶ Feedback comb filter for a given time constant (and delay).
y[n] = x[n] + alpha * y[n  delay]
Parameters:  delay – Feedback delay (lag), in number of samples.
 tau – Time decay (up to
1/e
, or 8.686 dB), in number of samples, which allows findingalpha = e ** (delay / tau)
. Defaults toinf
(infinite), which means alpha = 1.
Returns: A ZFilter instance with the comb filter.
See also
freq2lag
 Frequency (in rad/sample) to delay (in samples) converter.

fb
(delay, alpha=1)¶ Feedback comb filter for a given alpha and delay.
y[n] = x[n] + alpha * y[n  delay]
Parameters:  delay – Feedback delay (lag), in number of samples.
 alpha – Exponential decay gain. You can find it from time decay
tau
in the impulse response, bringing usalpha = e ** (delay / tau)
. Seecomb.tau
strategy if that’s the case. Defaults to 1 (no decay).
Returns: A ZFilter instance with the comb filter.
See also
freq2lag
 Frequency (in rad/sample) to delay (in samples) converter.

ff
(delay, alpha=1)¶ Feedforward comb filter for a given alpha (and delay).
y[n] = x[n] + alpha * x[n  delay]
Parameters:  delay – Feedback delay (lag), in number of samples.
 alpha – Memory value gain.
Returns: A ZFilter instance with the comb filter.
See also
freq2lag
 Frequency (in rad/sample) to delay (in samples) converter.
lazy_filters.resonator
StrategyDict¶
This is a StrategyDict instance object called
resonator
. Strategies stored: 4.
Strategy resonator.freq_poles_exp. Docstring starts with:
Resonator filter with 2poles (conjugated pair) and no zeros (constant numerator), with exponential approximation for bandwidth calculation. Given frequency is the denominator frequency, not the resonant frequency.
Strategy resonator.freq_z_exp. Docstring starts with:
Resonator filter with 2zeros and 2poles (conjugated pair). The zeros are at the 1 and 1 (both at the real axis, i.e., at the DC and the Nyquist rate), with exponential approximation for bandwidth calculation. Given frequency is the denominator frequency, not the resonant frequency.
Strategy resonator.poles_exp (Default). Docstring starts with:
Resonator filter with 2poles (conjugated pair) and no zeros (constant numerator), with exponential approximation for bandwidth calculation.
Strategy resonator.z_exp. Docstring starts with:
Resonator filter with 2zeros and 2poles (conjugated pair). The zeros are at the 1 and 1 (both at the real axis, i.e., at the DC and the Nyquist rate), with exponential approximation for bandwidth calculation.
Note
This docstring is selfgenerated, see the StrategyDict class and the strategies docs for more details.

z_exp
(freq, bandwidth)¶ Resonator filter with 2zeros and 2poles (conjugated pair). The zeros are at the 1 and 1 (both at the real axis, i.e., at the DC and the Nyquist rate), with exponential approximation for bandwidth calculation.
Parameters:  freq – Resonant frequency in rad/sample (max gain).
 bandwidth – Bandwidth frequency range in rad/sample following the equation:
R = exp(bandwidth / 2)
where R is the pole amplitude (radius).
Returns: A ZFilter object. Gain is normalized to have peak with 0 dB (1.0 amplitude).

freq_z_exp
(freq, bandwidth)¶ Resonator filter with 2zeros and 2poles (conjugated pair). The zeros are at the 1 and 1 (both at the real axis, i.e., at the DC and the Nyquist rate), with exponential approximation for bandwidth calculation. Given frequency is the denominator frequency, not the resonant frequency.
Parameters:  freq – Denominator frequency in rad/sample (not the one with max gain).
 bandwidth – Bandwidth frequency range in rad/sample following the equation:
R = exp(bandwidth / 2)
where R is the pole amplitude (radius).
Returns: A ZFilter object. Gain is normalized to have peak with 0 dB (1.0 amplitude).

poles_exp
(freq, bandwidth)¶ Resonator filter with 2poles (conjugated pair) and no zeros (constant numerator), with exponential approximation for bandwidth calculation.
Parameters:  freq – Resonant frequency in rad/sample (max gain).
 bandwidth – Bandwidth frequency range in rad/sample following the equation:
R = exp(bandwidth / 2)
where R is the pole amplitude (radius).
Returns: A ZFilter object. Gain is normalized to have peak with 0 dB (1.0 amplitude).

freq_poles_exp
(freq, bandwidth)¶ Resonator filter with 2poles (conjugated pair) and no zeros (constant numerator), with exponential approximation for bandwidth calculation. Given frequency is the denominator frequency, not the resonant frequency.
Parameters:  freq – Denominator frequency in rad/sample (not the one with max gain).
 bandwidth – Bandwidth frequency range in rad/sample following the equation:
R = exp(bandwidth / 2)
where R is the pole amplitude (radius).
Returns: A ZFilter object. Gain is normalized to have peak with 0 dB (1.0 amplitude).
lazy_filters.lowpass
StrategyDict¶
This is a StrategyDict instance object called
lowpass
. Strategies stored: 4.
Strategy lowpass.pole (Default). Docstring starts with:
Digital lowpass filter with one pole and no zeros (constant numerator).
Strategy lowpass.pole_exp. Docstring starts with:
Matched ZTransform lowpass filter with one pole and no zeros (constant numerator).
Strategy lowpass.z. Docstring starts with:
Digital lowpass filter with one pole and one zero.
Strategy lowpass.z_exp. Docstring starts with:
Matched ZTransform lowpass filter with one pole and one zero.
Note
This docstring is selfgenerated, see the StrategyDict class and the strategies docs for more details.

z_exp
(cutoff)¶ Matched ZTransform lowpass filter with one pole and one zero.
This strategy uses an exponential approximation for cutoff frequency calculation, found by matching the single pole and single zero Laplace highpass filter and mirroring the resulting filter to get a lowpass.
Parameters: cutoff – Cutoff frequency given in rad/sample. Should be a value (or a Stream of values) ranging from \(0\) (DC/constant level) up to \(\pi\) (Nyquist frequency). This value is used to find the pole amplitude (radius) \(R = e^{cutoff  \pi}\). Returns: A ZFilter object. Gain is normalized to have peak with 0 dB (1.0 amplitude) at the DC frequency (zero rad/sample). Cutoff frequency is unreliable outside the \([5\pi/6; \pi]\) range. Note
The digital filter design for this filter strategy (lowpass.z_exp) can be found in the AudioLazy
math
directory, both in the source distribution package and in main repository. That directory contains the code for finding the filter parameters (symbolic, using Sympy), besides the design details.See also
sHz
 Second and hertz constants from samples/second rate.

pole_exp
(cutoff)¶ Matched ZTransform lowpass filter with one pole and no zeros (constant numerator).
This strategy uses an exponential approximation for cutoff frequency calculation, found by matching the onepole Laplace lowpass filter.
Parameters: cutoff – Cutoff frequency given in rad/sample. Should be a value (or a Stream of values) ranging from \(0\) (DC/constant level) up to \(\pi\) (Nyquist frequency). This value is used to find the pole amplitude (radius) \(R = e^{cutoff}\). Returns: A ZFilter object. Gain is normalized to have peak with 0 dB (1.0 amplitude) at the DC frequency (zero rad/sample). Cutoff frequency is unreliable outside the \([0; \pi/6]\) range. Note
The digital filter design for this filter strategy (lowpass.pole_exp) can be found in the AudioLazy
math
directory, both in the source distribution package and in main repository. That directory contains the code for finding the filter parameters (symbolic, using Sympy), besides the design details.See also
sHz
 Second and hertz constants from samples/second rate.

z
(cutoff)¶ Digital lowpass filter with one pole and one zero.
This strategy uses a highprecision cutoff frequency calculation.Parameters: cutoff – Cutoff frequency given in rad/sample. Should be a value (or a Stream of values) ranging from \(0\) (DC/constant level) up to \(\pi\) (Nyquist frequency). It defines the filter frequency in which the squared gain is 50% the input gain (i.e, when magnitude gain is \(\sqrt{2}/2\) and power gain is about 3.0103 dB). Returns: A ZFilter object. Gain is normalized to have peak with 0 dB (1.0 amplitude) at the DC frequency (zero rad/sample). Note
The digital filter design for this filter strategy (lowpass.z) can be found in the AudioLazy
math
directory, both in the source distribution package and in main repository. That directory contains the code for finding the filter parameters (symbolic, using Sympy), besides the design details.See also
sHz
 Second and hertz constants from samples/second rate.

pole
(cutoff)¶ Digital lowpass filter with one pole and no zeros (constant numerator).
This strategy uses a highprecision cutoff frequency calculation.Parameters: cutoff – Cutoff frequency given in rad/sample. Should be a value (or a Stream of values) ranging from \(0\) (DC/constant level) up to \(\pi\) (Nyquist frequency). It defines the filter frequency in which the squared gain is 50% the input gain (i.e, when magnitude gain is \(\sqrt{2}/2\) and power gain is about 3.0103 dB). Returns: A ZFilter object. Gain is normalized to have peak with 0 dB (1.0 amplitude) at the DC frequency (zero rad/sample). Note
The digital filter design for this filter strategy (lowpass.pole) can be found in the AudioLazy
math
directory, both in the source distribution package and in main repository. That directory contains the code for finding the filter parameters (symbolic, using Sympy), besides the design details.See also
sHz
 Second and hertz constants from samples/second rate.
lazy_filters.highpass
StrategyDict¶
This is a StrategyDict instance object called
highpass
. Strategies stored: 4.
Strategy highpass.pole. Docstring starts with:
Digital highpass filter with one pole and no zeros (constant numerator).
Strategy highpass.pole_exp. Docstring starts with:
Matched ZTransform highpass filter with one pole and no zeros (constant numerator).
Strategy highpass.z (Default). Docstring starts with:
Digital highpass filter with one pole and one zero.
Strategy highpass.z_exp. Docstring starts with:
Matched ZTransform highpass filter with one pole and one zero.
Note
This docstring is selfgenerated, see the StrategyDict class and the strategies docs for more details.

z_exp
(cutoff)¶ Matched ZTransform highpass filter with one pole and one zero.
This strategy uses an exponential approximation for cutoff frequency calculation, found by matching the single pole and single zero Laplace highpass filter.
Parameters: cutoff – Cutoff frequency given in rad/sample. Should be a value (or a Stream of values) ranging from \(0\) (DC/constant level) up to \(\pi\) (Nyquist frequency). This value is used to find the pole amplitude (radius) \(R = e^{cutoff}\). Returns: A ZFilter object. Gain is normalized to have peak with 0 dB (1.0 amplitude) at the Nyquist frequency (pi rad/sample). Cutoff frequency is unreliable outside the \([0; \pi/6]\) range. Note
The digital filter design for this filter strategy (highpass.z_exp) can be found in the AudioLazy
math
directory, both in the source distribution package and in main repository. That directory contains the code for finding the filter parameters (symbolic, using Sympy), besides the design details.See also
sHz
 Second and hertz constants from samples/second rate.

pole_exp
(cutoff)¶ Matched ZTransform highpass filter with one pole and no zeros (constant numerator).
This strategy uses an exponential approximation for cutoff frequency calculation, found by matching the onepole Laplace lowpass filter and mirroring the resulting filter to get a highpass.
Parameters: cutoff – Cutoff frequency given in rad/sample. Should be a value (or a Stream of values) ranging from \(0\) (DC/constant level) up to \(\pi\) (Nyquist frequency). This value is used to find the pole amplitude (radius) \(R = e^{cutoff  \pi}\). Returns: A ZFilter object. Gain is normalized to have peak with 0 dB (1.0 amplitude) at the Nyquist frequency (pi rad/sample). Cutoff frequency is unreliable outside the \([5\pi/6; \pi]\) range. Note
The digital filter design for this filter strategy (highpass.pole_exp) can be found in the AudioLazy
math
directory, both in the source distribution package and in main repository. That directory contains the code for finding the filter parameters (symbolic, using Sympy), besides the design details.See also
sHz
 Second and hertz constants from samples/second rate.

z
(cutoff)¶ Digital highpass filter with one pole and one zero.
This strategy uses a highprecision cutoff frequency calculation.Parameters: cutoff – Cutoff frequency given in rad/sample. Should be a value (or a Stream of values) ranging from \(0\) (DC/constant level) up to \(\pi\) (Nyquist frequency). It defines the filter frequency in which the squared gain is 50% the input gain (i.e, when magnitude gain is \(\sqrt{2}/2\) and power gain is about 3.0103 dB). Returns: A ZFilter object. Gain is normalized to have peak with 0 dB (1.0 amplitude) at the Nyquist frequency (pi rad/sample). Note
The digital filter design for this filter strategy (highpass.z) can be found in the AudioLazy
math
directory, both in the source distribution package and in main repository. That directory contains the code for finding the filter parameters (symbolic, using Sympy), besides the design details.See also
sHz
 Second and hertz constants from samples/second rate.

pole
(cutoff)¶ Digital highpass filter with one pole and no zeros (constant numerator).
This strategy uses a highprecision cutoff frequency calculation.Parameters: cutoff – Cutoff frequency given in rad/sample. Should be a value (or a Stream of values) ranging from \(0\) (DC/constant level) up to \(\pi\) (Nyquist frequency). It defines the filter frequency in which the squared gain is 50% the input gain (i.e, when magnitude gain is \(\sqrt{2}/2\) and power gain is about 3.0103 dB). Returns: A ZFilter object. Gain is normalized to have peak with 0 dB (1.0 amplitude) at the Nyquist frequency (pi rad/sample). Note
The digital filter design for this filter strategy (highpass.pole) can be found in the AudioLazy
math
directory, both in the source distribution package and in main repository. That directory contains the code for finding the filter parameters (symbolic, using Sympy), besides the design details.See also
sHz
 Second and hertz constants from samples/second rate.