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 Z-transform frequency domain equations. |
z | Linear filters based on Z-transform 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
- Zeros-poles 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 zero-pole 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 zero-valued “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 zero-pole 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 Z-transform 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 “pre-input”):>>> 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 future-data delay in positive
z
exponents). Non-linear 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
- Zeros-poles 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 zero-pole plane plot.
-
zplot
(fig=None, circle=True)¶ Plots the filter zero-pole 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 self-generated, 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 2-poles (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 2-zeros and 2-poles (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 2-poles (conjugated pair) and no zeros (constant numerator), with exponential approximation for bandwidth calculation.
Strategy resonator.z_exp. Docstring starts with:
Resonator filter with 2-zeros and 2-poles (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 self-generated, see the StrategyDict class and the strategies docs for more details.
-
z_exp
(freq, bandwidth)¶ Resonator filter with 2-zeros and 2-poles (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 2-zeros and 2-poles (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 2-poles (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 2-poles (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 Z-Transform 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 Z-Transform lowpass filter with one pole and one zero.
Note
This docstring is self-generated, see the StrategyDict class and the strategies docs for more details.
-
z_exp
(cutoff)¶ Matched Z-Transform lowpass filter with one pole and one zero.
This strategy uses an exponential approximation for cut-off 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 – Cut-off 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). Cut-off 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 Z-Transform lowpass filter with one pole and no zeros (constant numerator).
This strategy uses an exponential approximation for cut-off frequency calculation, found by matching the one-pole Laplace lowpass filter.
Parameters: cutoff – Cut-off 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). Cut-off 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 high-precision cut-off frequency calculation.Parameters: cutoff – Cut-off 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 high-precision cut-off frequency calculation.Parameters: cutoff – Cut-off 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 Z-Transform 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 Z-Transform highpass filter with one pole and one zero.
Note
This docstring is self-generated, see the StrategyDict class and the strategies docs for more details.
-
z_exp
(cutoff)¶ Matched Z-Transform highpass filter with one pole and one zero.
This strategy uses an exponential approximation for cut-off frequency calculation, found by matching the single pole and single zero Laplace highpass filter.
Parameters: cutoff – Cut-off 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). Cut-off 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 Z-Transform highpass filter with one pole and no zeros (constant numerator).
This strategy uses an exponential approximation for cut-off frequency calculation, found by matching the one-pole Laplace lowpass filter and mirroring the resulting filter to get a highpass.
Parameters: cutoff – Cut-off 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). Cut-off 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 high-precision cut-off frequency calculation.Parameters: cutoff – Cut-off 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 high-precision cut-off frequency calculation.Parameters: cutoff – Cut-off 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.