DSP - BLOCK KURTOSIS

Introduction link

The Block Kurtosis block chops the input stream into consecutive blocks of N samples and, at the end of each block, publishes the kurtosis of that block:

$$ \mathrm{mean} = \frac{1}{N}\sum_{i=0}^{N-1} x_i , \qquad m_k = \frac{1}{N}\sum_{i=0}^{N-1} (x_i - \mathrm{mean})^k $$

$$ \mathrm{kurt} = \frac{m_4}{\sigma^4} = \frac{m_4}{m_2^{2}} $$

It is the normalised fourth central moment, and what it measures is TAILEDNESS: how much of the variance comes from rare large excursions rather than from many ordinary ones.

N is a runtime input, not a property. You drive the exponent on the EXP pin and the block size is $N = 2^{\mathrm{EXP}}$:

How to read the number link

These are the reference points worth remembering:

Kurtosis is dimensionless and gain independent: multiply every sample by ten and it does not move. A rare pulse, on the other hand, moves it hard. That combination is the whole point of the block.

THIS IS PLAIN KURTOSIS, NOT EXCESS KURTOSIS link

Some textbooks and most statistics packages report excess kurtosis, $m_4/\sigma^4 - 3$, so that Gaussian noise reads 0 instead of 3. This block reports the plain value: Gaussian noise reads 3.0.

If you want the excess convention, subtract 3.0 downstream - it is one constant subtraction in your own Q format, it costs one adder, and it is not worth a property here (nor worth making the output signed for, since only the excess form can be negative).

What it is FOR link

This is the classic “is something happening in this channel” detector, and it is worth being precise about why:

• a rare pulse moves it hard. A single full-scale outlier in a block of N otherwise-equal samples takes the kurtosis to about N - so at N = 1024 a single spike reads over a thousand while a quiet channel reads under 2. That is a dynamic range no threshold detector gives you for free.
• gain does not move it at all. You do not have to know, or control, the channel gain. One threshold - “kurtosis above 5”, say - works on every channel of a system whose gains you never calibrated.
• it does not need a threshold on the signal. Unlike Block Threshold Count or Block Peak Count, nothing has to be told how big a pulse is. A signal that is only ever a few LSB above the noise still has a large kurtosis if its excursions are rare.

Typical uses: pile-up and spike detection, machine condition monitoring (a rising kurtosis on a vibration channel is the textbook early bearing-fault indicator), gaussianity checks on a noise channel, and channel liveness - deciding which of many channels is worth reading out.

No square root anywhere link

$\sigma^4$ is $(\sigma^2)^2$ - a SQUARE, not an odd power. Unlike Block Skewness, which needs $\sigma^3$ and therefore a root, this block contains no square root at all. The denominator is an exact integer square, and the only approximation in the whole answer is the floored quotient.

No histogram, no second pass, no buffer link

The obvious way to get a central moment is to compute the mean, go back over the samples and accumulate $(x - \mathrm{mean})^4$. That needs the block stored - a memory of $2^{\mathrm{EXP}}$ samples and a second pass, which would halve the throughput and put a BRAM in the design.

This block does none of that. It keeps four ordinary accumulators,

$$ S_1 = \sum x_i , \quad S_2 = \sum x_i^2 , \quad S_3 = \sum x_i^3 , \quad S_4 = \sum x_i^4 $$

each updated once per clock, and recovers the fourth central moment at the end of the block from an exact integer identity (see the description below).

Cost link

Per clock, while accumulating: three real multipliers - $x \cdot x$, $(x \cdot x) \cdot x$ and $(x \cdot x) \cdot (x \cdot x)$ - because they run at one sample per clock and cannot be serialised, plus the four accumulators.

In the tail: one reused shift-add stage (it does all five products) and one reused compare-subtract stage for the division. What the tail costs is CLOCKS, not multipliers - there is no DSP in the tail at all. This is the second most expensive tail in the family, after Block Correlation; see “Timing” below and budget a long block.

When to use this instead of Block Statistics link

The all-in-one Block Statistics block is not deprecated, but it does not compute kurtosis - there is no KURTOSIS pin over there, so for this number there is no choice to make: this block is the only way to get it.

The usual family rule still applies to everything around it:

• you want several statistics of the SAME block - mean and RMS and min/max of the same N samples - place one Block Statistics block. They share one accumulator set and one serial tail, so the second and third statistic are nearly free.
• you want exactly one number - use the matching per-operator block. Then you synthesise only that number, and nothing else reaches the synthesiser.

A Block Kurtosis block placed next to a Block Statistics block accumulates the same stream a second time: $S_1$ and $S_2$ exist in both. That is the price of a statistic the all-in-one block does not have, and it is usually worth paying - the alternative is a histogram.

Pin Description link

Properties link

The exact integer identity link

Expanding the fourth central moment and clearing the denominators turns the definition into a ratio of two integers built from the raw power sums:

$$ B = N^3 S_4 - 4 N^2 S_1 S_3 + 6 N S_1^2 S_2 - 3 S_1^4 ;=; N^4 m_4 $$

$$ D = N S_2 - S_1^2 ;=; N^2 m_2 ;\ge; 0 $$

$$ \mathrm{kurt} = \frac{B}{D^{2}} $$

Every factor of $N$ in there is a shift - N is a power of two - and the $N^4$ scalings cancel exactly between numerator and denominator. So neither $N$ nor the input fractional bits appear anywhere in the arithmetic: the answer is a pure ratio of two exact integers, built without a single premature rounding.

And because $\sigma^4$ is $D^2$ - a square, not an odd power - the denominator is formed by one more exact integer multiplication. There is no square root in this block, no root guard bits and no root error.

A constant block has no kurtosis, and the arithmetic says so link

If every sample equals $c$ then

$$ B = (1 - 4 + 6 - 3),N^4 c^4 = 0 \qquad\text{and}\qquad D = 0 $$

so the zero-denominator path always finds a zero numerator and reports 0. The saturating branch of the ratio is unreachable through the ports: a constant block reports 0, never a full-scale spike. (Mathematically the kurtosis of a constant is undefined; 0 is what this block reports, not 1.)

Accuracy: BIT EXACT link

The numerator and the denominator are exact integers and the only operation performed on them is the floored restoring division. That is not an aspiration: the host regression (tb/block-ops/run_tb.ps1) demands tolerance ZERO against a Python golden (tb/block-ops/gen_golden.py) which evaluates $m_4/m_2^2$ in exact rational arithmetic and floors it the same way the divider does. Not “within 1 LSB”, not “within a few counts” - any deviation at all fails the build.

Being floored means the value is biased low by up to one LSB - with the default 6 fractional bits, up to 1/64. If that matters at your threshold, ask for more fractional bits (and pay four clocks of tail per bit, see below).

Accumulation and IN_DV link

IN_DV is the only qualifier. It says “this clock carries a sample”: a sample is added into $S_1$, squared into $S_2$, cubed into $S_3$, raised to the fourth into $S_4$, and counts towards N, exactly on the clocks where IN_DV is high. Clocks with IN_DV low are ignored completely - whatever sits on IN during them cannot corrupt the block, and in particular cannot fake an outlier - while the serial tail keeps running, which is what you want: the tail has nothing to do with the input stream.

Unconnected, IN_DV ties to '1' and EXP ties to 10 (N = 1024), so the block free-runs with nothing wired except IN.

There is deliberately no CE pin. On the all-in-one Block Statistics block an earlier revision had one, and it did not survive synthesis: with nothing but internal state gated by it, Vitis could reason the frozen path away and delete the port from the generated entity while SciCompiler’s wrapper still wired it, which failed a real Vivado build with [VRFC 10-718] formal port <ce> does not exist in entity. The whole per-operator family was built without one. To stall this block, gate its IN_DV - a block that only accumulates on IN_DV has no need to be frozen, and there is no reason to stall the tail.

There is no LEVEL pin either: a central moment is referred to the block’s own mean, by definition.

When EXP changes link

EXP is clamped to Max Block Exponent and then latched on the first accepted sample of a block, and held for that whole block. A change therefore takes effect on the NEXT block: a block in progress always finishes against the N it was started with, and a block is never emitted against a different N than the one it was accumulated with. The latched exponent is the one used for every $N$, $N^2$ and $N^3$ shift in the identity, so the arithmetic of a block is always self-consistent.

Remember that N is also the scale of the answer on an impulsive signal: a single outlier reads about N, so halving the block halves the reading of a lone spike. A kurtosis threshold is only comparable between blocks of the same length.

Timing: the serial tail link

The state walk link

A block has a whole block period of slack after its N-th sample, so all post-accumulation arithmetic is serial. Five passes reuse one shift-add stage, and the ratio reuses one restoring-division stage:

  IDLE -(block complete)-> MUL2 (|S1|*|S1|) -> MULQ (|S1|*|S3|)
     -> MULR (|S1|^2*S2) -> MULF (|S1|^2*|S1|^2) -> VAR (form D and B)
     -> MULD (D*D) -> CLD -> DIV x CNUMW -> FIN -> IDLE
  

OUT_DV pulses for one clock when the tail COMPLETES - not when the N-th sample arrives - and KURTOSIS is updated on that same clock and on no other.

The latency contract link

Counted in clocks from the clock on which the N-th sample of the block was accepted:

$$ L = 8,\mathrm{IN_SW} + 7,\mathrm{EXP} + 1 + \mathrm{CNUMW} $$

where $\mathrm{IN_SW}$ is the signed working width of a sample - the input width, +1 if the input is UNSIGNED (a sample has to be promoted to signed before it can be accumulated) - and the divider width is fixed at compile time by your formats:

$$ \mathrm{CNUMW} = \max\bigl(4,(\mathrm{IN_SW} + \mathrm{MaxBlockExponent}) + \mathrm{KURT_{fract}},; \mathrm{KURTOSIS\ width} + 2\bigr) $$

The $7,\mathrm{EXP}$ comes from four of the five products (|S1| needs $\mathrm{IN_SW} + \mathrm{EXP}$ steps, $S_2$ needs $2,\mathrm{IN_SW} - 1 + \mathrm{EXP}$, and $|S_1|^2$ and $D$ need $2,\mathrm{IN_SW} - 1 + 2,\mathrm{EXP}$ each); the divider is fixed at compile time by your formats and by Max Block Exponent.

Note what this means: raising Max Block Exponent lengthens the tail here, unlike on Block Mean where it costs only accumulator width - it widens CNUMW by four clocks per unit. And the runtime exponent enters at seven clocks per unit, the steepest in the family. Both still lose to $2^{\mathrm{EXP}}$, so a longer block always has more slack, not less.

Worked numbers link

Take a 16 bit signed input at the default formats (KURTOSIS Q10.6 unsigned, Max Block Exponent 20):

• $\mathrm{IN_SW} = 16$
• $\mathrm{CNUMW} = \max(4 \cdot 36 + 6,; 16 + 2) = \max(150, 18) = 150$
• $L = 128 + 7,\mathrm{EXP} + 1 + 150 = 279 + 7,\mathrm{EXP}$

At EXP = 8 that is $L = 335$ clocks and $2^8 = 256 < 335$: it does not fit. At EXP = 9 it is $L = 342$ and $2^9 = 512 \ge 342$: it does. The minimum usable EXP is 9, a block of 512 samples, and every larger exponent fits too - the block grows exponentially while the tail grows linearly. At the default EXP = 10 the tail is 349 clocks inside a 1024-sample block, i.e. about 66 % idle.

A few more configurations, to show where the clocks go:

Budget a long block. Even the cheapest configuration in that table needs N = 256, and a 32 bit input needs N = 1024; there is no useful setting of this block that works at EXP = 5. That is rarely a real constraint, because a kurtosis estimated over 64 samples is a noisy statistic anyway - the fourth moment needs samples before it means anything - but it does mean you cannot use this block as a fast per-pulse discriminator.

The 2^EXP >= L rule, and what happens when it is broken link

The tail of one block must finish before the next block completes:

$$ 2^{\mathrm{EXP}} \ge L $$

A completed block is only handed to the tail when the tail is IDLE, so if a block completes while the previous tail is still running, that block’s result is DROPPED: there is no OUT_DV for it, the accumulators are unaffected and the following blocks come out correctly, but a result is silently skipped. There is no error pin and no overrun pin for it.

Two things guard against it, and one hole remains:

• the property page refuses a configuration whose minimum exponent exceeds Max Block Exponent, telling you the tail length and the exponent it would need;
• CompileHDL prints both numbers - the worst-case tail length and the minimum usable EXP - into the compilation log for every placement;
• but EXP is a PIN. Nothing can stop a design driving it too low at RUN TIME, and with L in the hundreds of clocks this is one of the two blocks where that bites hardest: an EXP of 6 that would be perfectly reasonable on Block Mean drops every result here. If EXP is under software control, clamp it in software to the minimum the compiler printed.

Knowing where the block is: BUSY, INTEGRATING and SAMPLE_COUNT link

Three optional status outputs, all defaulting to NO. They answer different questions, and on this block the difference is at its most useful, because the tail is long:

Every output of this block is a register, so each status bit is observed on the clock after the event that sets it:

• INTEGRATING rises on the clock after the FIRST sample of a block is accepted and falls on the clock after the N-th - it is high exactly while the block is ACCUMULATING, and never during the tail. BUSY high with INTEGRATING low is precisely the five-products-then-divide tail.
• BUSY covers the accumulation and the tail. It rises with INTEGRATING, stays high across the tail, and its LAST HIGH CLOCK IS THE OUT_DV PULSE; it falls on the clock after.
• On a continuous stream the next block starts before the previous tail ends, so BUSY never drops and INTEGRATING dips for exactly one clock per block boundary - which makes it a free block marker.
• SAMPLE_COUNT is a fixed 32 bits and reads 1 after the first accepted sample, N after the N-th. It is NOT cleared at the block end: it HOLDS the final count through the tail and past OUT_DV, until the first sample of the next block takes it back to 1. it reads N at OUT_DV only when the input STOPS for the whole tail. On a CONTINUOUS stream the next block has already started by then, so OUT_DV shows how far into it the input has got, not N - the clock that always reads N is the one INTEGRATING falls on - which is the useful thing to latch alongside the result, and here doubly so, because the reading of an impulsive block scales with N. Only RESET clears it to 0.

Q formats link

Both data ports carry their own fixed point format (integer bits, fractional bits, sign), the same convention as the Fixed P. family. The quotient already carries exactly KURT Fractional Bits fractional bits, so the final requantisation is a zero-bit shift: the value is not rounded again on the way out, only checked against the format bounds.

Sizing:

• the default output format is WIDE for a reason. A single full-scale outlier in a block of N otherwise-equal samples takes the kurtosis to about N, so at the default N = 1024 a lone spike reads about 1022. The default 10 integer bits hold up to 1023 - matched to exactly that case. If you run longer blocks and care about the value of an impulsive reading rather than just “it is large”, widen it or let it saturate deliberately.
• kurtosis is never negative and is always $\ge 1$ for a real block, so UNSIGNED is the default and buys you a bit. Choose SIGNED only if something downstream insists on a signed bus - the block will never drive a negative value.
• the fractional bits (default 6, steps of 1/64) are the resolution around the interesting thresholds - 1.5, 1.8, 3.0 - and each one costs four clocks of tail through CNUMW.
• the input Q format does not enter the value at all: the identity is scale free, so IN_BitsFract changes nothing about the answer (only the tail length, through IN_SW).

Verification link

The core is regression tested by a host-side csim harness (tb/block-ops/run_tb.ps1) that runs one simulated clock at a time and follows OUT_DV. The expected values come from tb/block-ops/gen_golden.py, which evaluates $m_4/m_2^2$ in exact rational arithmetic and shares no algorithm with the core; the tolerance is 0. Coverage includes an impulse pattern - rare full-scale spikes on a flat baseline, which drives the kurtosis into the tens and exercises the top of the output format - a two-level extremes pattern (the least tailed signal there is, kurtosis exactly 1), a sine (1.5), pseudo-random input (about 1.8), a constant block (the D == 0 path, which must read 0 and not saturate) and an UNSIGNED 8 bit input to exercise the promotion. The tail length is checked at compile time: three copies of the formula exist - the BKU_TAIL macro in the core, tail_len() in the generator and TailClocks() in the plugin - and the testbench refuses to build if they disagree. The status outputs are checked clock by clock against the contract above.