MoogLadderFilter Class Reference

Simplified Moog ladder filter with bilinear transform accuracy. More...

#include <BilinearTransformMoogLadderFilter.h>

Public Member Functions
	MoogLadderFilter (float rate)
	Construct simplified Moog ladder filter.
void	setSampleRate (float rate)
	Update sample rate and recalculate coefficients.
void	setCutoff (float cutoffHz)
	Set cutoff frequency with bilinear transform compensation.
void	setResonance (float res)
	Set resonance amount with classic Moog scaling.
float	process (float input)
	Process single audio sample through simplified ladder.
	MoogLadderFilter (float sampleRate)
	Construct Moog ladder filter with specified sample rate.
void	setSampleRate (float rate)
	Update sample rate and recalculate coefficients.
void	setCutoff (float cutoffHz)
	Set filter cutoff frequency with automatic coefficient update.
void	setResonance (float resonanceAmount)
	Set filter resonance amount with feedback calculation.
float	process (float input)
	Process single audio sample through filter.

Private Member Functions
void	updateCoefficients ()
	Update filter coefficients when parameters change.
void	updateCoefficients ()
	Update filter coefficients when parameters change.

Private Attributes
float	sampleRate
	Audio system sample rate.
float	cutoff
	Current cutoff frequency in Hz.
float	resonance
	Current resonance amount [0.0-1.0].
float	tuning
	Bilinear transform tuning coefficient.
float	feedback
	Resonance feedback coefficient.
float	y [4] = {0.0f}
	Filter stage state variables [4 elements].
float	oldx = 0.0f
	Previous input sample for difference equations.
float	oldy = 0.0f
	Previous output sample for feedback calculation.

Detailed Description

Simplified Moog ladder filter with bilinear transform accuracy.

Educational implementation of Moog ladder filter using bilinear transform.

This class provides a straightforward implementation of the Moog ladder filter using bilinear transform frequency mapping and simplified cascade topology. The design prioritizes computational efficiency and implementation clarity while maintaining the essential musical characteristics of the Moog sound.

@key_features

• Bilinear Transform: Accurate frequency mapping from analog prototype
• Four-Pole Cascade: Traditional ladder structure with resonance feedback
• Nonlinear Saturation: tanh() saturation at each stage for analog character
• Simple Topology: Streamlined algorithm for educational and practical use
• Parameter Validation: Automatic range checking for stability

@computational_characteristics

• Complexity: ~20 floating-point operations per sample
• Memory: ~48 bytes (12 float members)
• Stability: Robust across all parameter ranges
• Precision: Single-precision floating-point throughout
• Efficiency: Optimized for real-time processing

This class provides a clear, straightforward implementation of the classic Moog ladder filter using bilinear transform methodology. The design emphasizes educational value and implementation clarity while maintaining the essential sonic characteristics that define the Moog sound.

@design_principles

• Educational Clarity: Every method and variable has obvious purpose and meaning
• Implementation Simplicity: Straightforward algorithms without complex optimizations
• Theoretical Correspondence: Direct relationship between code and filter theory
• Accessibility: Suitable for students and researchers learning digital filter design
• Extensibility: Clean foundation for developing more advanced implementations

@filter_characteristics

• Response Type: 24dB/octave lowpass with resonance peak
• Topology: Four cascaded one-pole sections with feedback
• Nonlinearity: Optional tanh saturation for analog character
• Frequency Range: Full audio bandwidth with proper sample rate scaling
• Resonance Behavior: Clean self-oscillation at maximum settings

@mathematical_implementation

• Bilinear Transform: Standard s-plane to z-plane conversion
• Frequency Pre-warping: tanf(π × fc / fs) compensation for frequency accuracy
• State Variable Structure: Direct implementation of difference equations
• Feedback Topology: Classic Moog-style negative feedback for resonance

@usage_example

MoogLadderFilter filter(44100.0f);
filter.setCutoff(1000.0f);     // 1kHz cutoff
filter.setResonance(0.6f);     // Moderate resonance
 
// Process audio samples
for (int i = 0; i < bufferSize; ++i) {
    float filtered = filter.process(inputBuffer[i]);
    outputBuffer[i] = filtered;
}

Constructor & Destructor Documentation

MoogLadderFilter() [1/2]

MoogLadderFilter::MoogLadderFilter

(

float

rate

)

Construct simplified Moog ladder filter.

Initialize simplified Moog ladder filter.

Parameters

rate	Sample rate for bilinear transform calculations

Initializes filter with default parameters and computes initial coefficients using bilinear transform frequency mapping.

MoogLadderFilter() [2/2]

MoogLadderFilter::MoogLadderFilter

(

float

sampleRate

)

Construct Moog ladder filter with specified sample rate.

Parameters

sampleRate

Audio processing sample rate for coefficient calculation

Initializes the filter with default parameters suitable for immediate use and calculates initial coefficients based on the specified sample rate.

Member Function Documentation

process() [1/2]

float MoogLadderFilter::process

(

float

input

)

Process single audio sample through simplified ladder.

Process sample through simplified ladder with nonlinear saturation.

Parameters

input

Input audio sample

Returns

Filtered audio sample

Core processing method implementing the four-pole cascade with nonlinear saturation and resonance feedback. Uses simplified topology for computational efficiency.

@algorithm_steps

1. Calculate input with resonance feedback
2. Process through four cascaded poles with tanh() saturation
3. Update state variables for next sample
4. Return final stage output

This method implements a streamlined version of the Moog ladder that captures the essential frequency response and nonlinear characteristics while maintaining computational efficiency suitable for real-time use.

Calculate input with resonance feedback from final stage This implements the negative feedback that creates resonance

Process through four cascaded one-pole lowpass sections Each section uses the bilinear transform tuning coefficient and includes tanh() saturation for nonlinear analog character

The algorithm implements: y[n] += tuning × (tanh(input) - tanh(y[n])) This provides both lowpass filtering and nonlinear saturation

Return final stage output This provides the complete 24dB/octave lowpass response with nonlinear saturation and resonance characteristics

process() [2/2]

float MoogLadderFilter::process

(

float

input

)

Process single audio sample through filter.

Parameters

input

Audio sample for filtering

Returns

Filtered audio sample

Core processing method implementing the four-pole ladder filter with resonance feedback and optional nonlinear saturation for analog character.

setCutoff() [1/2]

void MoogLadderFilter::setCutoff

(

float

cutoffHz

)

Set cutoff frequency with bilinear transform compensation.

Set cutoff frequency with validation and bilinear transform.

Parameters

cutoffHz

Cutoff frequency in Hz

Configures the filter cutoff frequency using bilinear transform for accurate frequency mapping from analog prototype to digital implementation.

@range [5Hz, 0.45 × sampleRate] automatically enforced @transform Uses tan(π × fc / fs) for frequency pre-warping

Clamp cutoff to safe range preventing aliasing and instability Upper limit of 0.45 × sampleRate provides safety margin below Nyquist

setCutoff() [2/2]

void MoogLadderFilter::setCutoff

(

float

cutoffHz

)

Set filter cutoff frequency with automatic coefficient update.

Parameters

cutoffHz

Cutoff frequency in Hz

Configures the filter cutoff frequency with range validation and automatic coefficient recalculation using bilinear transform with frequency pre-warping for accurate analog frequency matching.

setResonance() [1/2]

void MoogLadderFilter::setResonance

(

float

res

)

Set resonance amount with classic Moog scaling.

Set resonance with validation and coefficient update.

Parameters

res	Resonance amount [0.0-1.0]

Configures filter resonance using classic Moog-style scaling where feedback = resonance × 4.0 to account for the four-pole attenuation in the ladder structure.

@range [0.0-1.0] automatically enforced @scaling feedback = res × 4.0 (classic Moog relationship)

Clamp resonance to [0.0-1.0] range for stability

setResonance() [2/2]

void MoogLadderFilter::setResonance

(

float

resonanceAmount

)

Set filter resonance amount with feedback calculation.

Parameters

resonanceAmount

Resonance intensity [0.0-1.0]

Controls the amount of positive feedback that creates the characteristic resonance peak. Higher values produce more prominent peaks and can lead to self-oscillation at the cutoff frequency.

setSampleRate() [1/2]

void MoogLadderFilter::setSampleRate

(

float

rate

)

Update sample rate and recalculate coefficients.

Update sample rate with coefficient recalculation.

Parameters

rate	New sample rate in Hz

Allows dynamic sample rate changes with automatic coefficient recalculation to maintain frequency accuracy.

setSampleRate() [2/2]

void MoogLadderFilter::setSampleRate

(

float

rate

)

Update sample rate and recalculate coefficients.

Parameters

rate	New sample rate for coefficient recalculation

Allows dynamic sample rate changes with automatic coefficient updates to maintain proper frequency response characteristics.

updateCoefficients() [1/2]

void MoogLadderFilter::updateCoefficients ( )

private

Update filter coefficients when parameters change.

Update coefficients using bilinear transform relationships.

Recalculates tuning and feedback coefficients using bilinear transform relationships when cutoff or resonance changes.

This method implements the core bilinear transform calculations that provide accurate frequency mapping from analog prototype to digital implementation while maintaining computational efficiency.

Calculate normalized frequency for bilinear transform

Apply bilinear transform frequency pre-warping tuning = tan(π × fc) compensates for frequency compression in bilinear transform, ensuring accurate cutoff frequency

Calculate feedback coefficient using classic Moog scaling Factor of 4.0 accounts for cumulative attenuation through four filter poles in the ladder structure

updateCoefficients() [2/2]

void MoogLadderFilter::updateCoefficients ( )

private

Update filter coefficients when parameters change.

Recalculates tuning and feedback coefficients using bilinear transform methodology when cutoff frequency or resonance parameters are modified.

Member Data Documentation

cutoff

float MoogLadderFilter::cutoff

private

Current cutoff frequency in Hz.

feedback

float MoogLadderFilter::feedback

private

Resonance feedback coefficient.

Resonance feedback gain coefficient.

Calculated as resonance × 4.0 using classic Moog scaling to account for four-pole attenuation in feedback path.

oldx

float MoogLadderFilter::oldx = 0.0f

private

Previous input sample for difference equations.

oldy

float MoogLadderFilter::oldy = 0.0f

private

Previous output sample for feedback calculation.

resonance

float MoogLadderFilter::resonance

private

Current resonance amount [0.0-1.0].

sampleRate

float MoogLadderFilter::sampleRate

private

Audio system sample rate.

System parameters.

Audio processing sample rate

tuning

float MoogLadderFilter::tuning

private

Bilinear transform tuning coefficient.

Pre-computed coefficients for efficient processing.

Computed as tan(π × cutoff / sampleRate) for frequency pre-warping compensation in bilinear transform.

Bilinear transform coefficient with pre-warping

y

float MoogLadderFilter::y = {0.0f}

private

Filter stage state variables [4 elements].

Filter state variables.

Internal state of each filter pole in the cascade structure. These maintain the temporal memory of the filter.

Filter stage outputs (4-pole cascade)

---

The documentation for this class was generated from the following files:

• DEV/BilinearTransformMoogLadderFilter.h
• DEV/MoogLadderFilter.h
• DEV/BilinearTransformMoogLadderFilter.cpp