Gaussian Noise Generator (GNG)

Introduction link

The Gaussian Noise Generator (GNG) block generates true Gaussian (normally distributed) noise starting from an internal Pseudo-Random Number Generator (PRNG). The output is in signed integer format and can be combined with an input signal to add controllable random noise.

This component is useful for testing signal processing chains, simulating noisy signals, or adding dithering to signals.

Pin Description link

Properties link

Usage link

Algorithm Overview link

The GNG uses a Combined Tausworthe Generator (CTG) to produce uniformly distributed random numbers, followed by a polynomial interpolation stage that transforms the uniform distribution into a Gaussian distribution.

The algorithm implements the inverse cumulative distribution function (CDF) of the Gaussian distribution using piecewise polynomial approximation.

Architecture link

The implementation consists of three main stages:

1. Combined Tausworthe PRNG (CTG)

   • Uses three 64-bit Linear Feedback Shift Registers (LFSRs)
   • XOR combination produces 64-bit uniform random values
   • Initialized with a proprietary seed for maximum sequence length

2. Leading Zero Detector (LZD)

   • Counts leading zeros in the random value
   • Maps uniform distribution to exponential-like distribution

3. Polynomial Interpolator

   • 248-entry coefficient lookup table
   • Second-order polynomial approximation
   • Converts to Gaussian distribution with fixed-point arithmetic

Output Characteristics link

The output noise follows a Gaussian distribution:

$$ f(x) = \frac{1}{\sigma\sqrt{2\pi}} e^{-\frac{(x-\mu)^2}{2\sigma^2}} $$

where:

• $\mu$ = 0 (zero mean, before offset)
• $\sigma$ is proportional to the GAIN input

The noise is generated in signed 16-bit format with approximately 11 fractional bits (s<16,11>).

Gain Control link

The GAIN input controls the noise amplitude (standard deviation). It is an unsigned fixed-point multiplier with 14 fractional bits, i.e. the noise sample is multiplied by GAIN / 0x4000, so 0x4000 is unity gain:

The relationship is linear, the product is truncated (not rounded) and the output sum is not saturated: with a large GAIN an extreme sample can wrap in 16 bits instead of clipping, so pick the gain from the amplitude the design needs rather than from the top of the range.

Signal Mixing link

The block performs the following operation:

$$ \text{NOISE} = \text{OFFSET} + \text{GN} \times \text{GAIN} $$

where GN is the internal Gaussian noise sample. This allows:

• Adding a DC offset to the noise
• Mixing noise with an external signal (connect signal to OFFSET)
• Creating noisy versions of clean signals

Seed Configuration link

The seed is exactly 48 hexadecimal digits and it is the raw initial state of the three Tausworthe components - there is no seeding logic in the hardware, the three fields are loaded as they are:

Any other 48-digit hexadecimal value is a valid seed; in particular repeated digits, three identical fields, and the three minimums themselves are all perfectly usable states.

Why each field has its own minimum. A component whose value is below its minimum has nothing above the bits its feedback discards, so its next state is zero and it is then stuck at zero for ever. The limit is per field: one field below its minimum silently reduces the generator from three components to two (period from about 2^176 down to 2^118) while the output still looks like noise, and with all three fields below their minimum the block emits a constant instead of noise.

What the tool does about it:

• the EDIT button generates a seed that always satisfies the three minimums, so an automatically generated seed is never degenerate;
• a hand-typed seed that is not 48 hexadecimal digits, or that has any field below its minimum, is refused when the property window is confirmed, with a message naming the field: a degenerate seed can no longer be saved;
• a project saved before this check existed still builds: at compile time the offending fields are replaced and the compiler prints a warning naming the field and the seed actually used. That replacement is derived from the stored seed text and from the block designator, so every build of the same project gets the same seed (the run stays reproducible, and the printed value can be pasted back into the property), while two blocks that stored the same degenerate seed get different replacements and stay independent.

Different seeds produce statistically independent sequences; the same seed always produces the same sequence, and RESET replays it from the beginning.

Timing link

All the numbers below are measured on the block’s own regression run (ci-test/ci-sim/gng_top), not estimated.

The 14 clocks are 10 of noise engine, 3 of the GAIN multiplier and 1 of the output register; the OFFSET input only crosses that last register, which is why a signal connected to OFFSET is delayed by one clock and not by 14.

VALID is exactly aligned with the sample it qualifies: NOISE is meaningful while VALID is high and is pipeline content while VALID is low - after a RESET the arithmetic pipeline is not cleared, so the samples of the 14-clock refill are leftovers and VALID low is the only thing marking them.

Start-up reset (once per configuration) link

The block resets its noise engine by itself after power-up or reconfiguration: an internal counter asserts the engine’s reset on clock 18 and releases it on clock 129, so the first valid noise sample of a configuration arrives on clock 144 (129 + the 14 clocks of the pipeline).

This warm-up happens once. The RESET pin does not repeat it: a RESET reloads the seed words and replays the sequence from its first sample after the usual 14 clocks, while the start-up counter keeps its value. In a real design the 144 clocks are over long before the first acquisition.

Resources & Timing link

• Latency: 14 clock cycles (noise path); OFFSET to NOISE 1 clock cycle

• Throughput: 1 sample per clock cycle