DSP - BLOCK LINEAR REGRESSION

Introduction link

The Block Linear Regression block chops the input stream into consecutive blocks of N samples and, at the end of each block, publishes the least-squares straight line fitted to that block against the sample index:

$$ x_i ;\approx; \mathrm{INTERCEPT} + \mathrm{SLOPE}\cdot i , \qquad i = 0 \ldots N-1 $$

It is the line that minimises $\sum_i (x_i - \mathrm{INTERCEPT} - \mathrm{SLOPE}\cdot i)^2$ over the block. Two numbers come out:

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}}$:

What it is FOR: DRIFT REMOVAL link

A drifting baseline is the thing that ruins every other statistic in this family. It inflates Block Std Dev and Block Variance (the drift itself becomes “spread”), it hides a real change in Block Mean, it moves the skewness off zero, and it makes Block Threshold Count depend on when you looked rather than on what the signal did.

This block measures the drift so you can take it out. Feed SLOPE and INTERCEPT to a downstream subtracter - reconstruct $\mathrm{INTERCEPT} + \mathrm{SLOPE}\cdot i$ with a counter and an accumulator, or drive a DAC on a baseline-restore loop - and the linear trend is gone from the next block. Everything downstream then measures the signal instead of the drift.

(The fit describes the block that has just finished, so applying it to the next block assumes the drift continues at the same rate. That is the usual baseline-restore assumption, and it is a good one for thermal drift, leakage and slow bias movement - the things this block exists for.)

And as a measurement in its own right link

SLOPE on its own is a direct “how fast is this detector warming up” readout: degrees, volts or counts per sample, straight out of a pin, with no differentiation and no noise amplification. Fitting a line across N samples averages the noise down instead of amplifying it, which is exactly what a first difference does not do.

THERE IS NOT ONE MULTIPLIER IN THIS BLOCK link

Not one - not even a serial one. That is the headline engineering fact about this block, and it comes from two observations.

1. The regressor is the sample INDEX, which is known. $\sum i$ and $\sum i^2$ are closed forms in N, and N is a power of two, so every one of them is a SHIFT. Written about the centred index $w_i = 2i - (N-1)$ the normal equations collapse to

$$ \mathrm{SLOPE} = \frac{6,S_w}{N(N^2-1)} , \qquad \mathrm{INTERCEPT} = \frac{(N+1)S_x - 3 S_w}{N(N+1)} , \qquad S_w = \sum_i w_i x_i $$

and both denominators are built from N by shifts and one add: $N(N^2-1) = 2^{3E} - 2^{E}$ and $N(N+1) = 2^{2E} + 2^{E}$.

2. $S_w$ itself needs no multiplier either. With $R_i$ the running sum of $x_0 \ldots x_i$ and $A = \sum_i R_i$,

$$ \sum_i i,x_i = N S_x - A , \qquad S_w = (N+1)S_x - 2A $$

so TWO CASCADED ACCUMULATORS replace the index multiply completely - $S_x$ is simply $R$ at the end of the block. The whole per-sample datapath of this block is two adders.

The only real arithmetic left is the two divisions, by $N(N^2-1)$ and $N(N+1)$, which genuinely are not powers of two. They share one reused restoring-division stage.

Cost link

Per clock, while accumulating: two adders. No multiplier, no DSP, no sample buffer, no memory.

In the tail: one reused compare-subtract stage, run once per enabled output. Turning an output off really does remove its division, its pin and its clocks - a slope-only placement has half the tail of a two-output one.

When to use this instead of Block Statistics link

The all-in-one Block Statistics block is not deprecated, but it does not fit a line - there is no SLOPE or INTERCEPT pin over there, so for these numbers there is no choice to make: this block is the only way to get them.

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 Linear Regression block next to a Block Statistics block accumulates the same stream a second time - but here that second accumulation is two adders, which is about as cheap as a duplicate can be.

Pin Description link

Properties link

The algebra, and how to check it by hand link

Per accepted sample the core keeps exactly two registers:

$$ R_i = R_{i-1} + x_i \quad (\text{so } S_x = R_{N-1}) , \qquad A = A + R_i $$

and at the end of the block, in one clock of shifts and adds:

$$ S_w = (N+1)S_x - 2A , \qquad \mathrm{SLOPE} = \frac{6 S_w}{2^{3E} - 2^{E}} , \qquad \mathrm{INTERCEPT} = \frac{(N+1)S_x - 3 S_w}{2^{2E} + 2^{E}} $$

Worth checking on paper once, because it is not obvious that this is a fit at all:

A clean ramp is an exact fit - the residual is zero and both outputs are exactly right - which is the strongest single check of the algebra, and it is in the regression suite.

N == 1 has no slope link

A single point has nothing to fit, and the arithmetic reaches that on its own: $N(N^2-1) = 0$ and the numerator $6 S_w$ is 0 as well, so the zero-denominator path reports SLOPE = 0. The intercept is still perfectly well defined - $N(N+1) = 2$, and it comes out as the sample itself.

No sane configuration asks for EXP = 0, but EXP is a PIN, so this is reachable at run time and it is defined rather than left to chance.

UNITS: size SLOPE’s fraction generously link

This is the one thing to get right on this block.

SLOPE is in input units per SAMPLE INDEX, not per block and not per second. That makes it a small number: a baseline that drifts by one input LSB across a whole 1024-sample block has a slope of

$$ \frac{1}{1024} = 2^{-10} $$

So the slope LSB has to be much smaller than that or every slow drift quantises to zero:

Give SLOPE plenty of FRACTIONAL bits. The default is 16, and that is the right order of magnitude for a drift measurement; do not cut it down to “match the input” - the input’s format has nothing to do with it.

Its integer bits are the opposite problem and rarely bind: 8 signed bits cover $\pm 127$ input units of change per sample, which is a ramp that traverses the full scale of a 16 bit input in about 500 samples. If you are fitting something that steep, widen them.

INTERCEPT has the units of the input, so size it like the input: at least the input’s integer bits. Its fractional bits (default 8) are pure resolution - the fitted value at $i = 0$ is an average of N samples, so it is known to far better than one input LSB and it is worth asking for the extra bits. Note that a noisy steep fit can extrapolate the intercept slightly outside the range of the block’s samples, so keep Saturation on.

Accuracy link

Both divisions carry SQG = 4 guard bits underneath the requested Q format, so the final requantisation still has something to round with, and then the result is requantised with the selected rounding. Both outputs are therefore within 1 LSB of the exactly-rounded value, and the host regression asserts exactly that: tolerance 1 LSB against a Python golden (tb/block-ops/gen_golden.py) that solves the normal equations in exact rational arithmetic and shares no algorithm with the core.

Everything before the divisions is exact integer arithmetic: the two accumulators, the closed-form denominators and $S_w$ are all built from shifts and adds with no intermediate rounding at all.

Accumulation and IN_DV link

IN_DV is the only qualifier. It says “this clock carries a sample”: a sample enters the running sum $R$, $R$ enters $A$, and the sample 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 - while the serial tail keeps running, which is what you want: the tail has nothing to do with the input stream.

Note the consequence for the fit: the index $i$ counts ACCEPTED samples, not clocks. A gap in IN_DV does not leave a hole in the regressor - the samples either side of it are consecutive as far as the fit is concerned. If your IN_DV gaps are irregular and you want a drift rate per unit time rather than per sample, scale the slope downstream by the average duty cycle.

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.

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 what both denominators - $2^{3E}-2^{E}$ and $2^{2E}+2^{E}$ - are built from, so a block is never divided by the wrong N.

Timing: the serial tail link

The state walk link

  IDLE -(block complete)-> CALC (one clock: all shifts and adds)
     -> DIVS x CNUMW (slope)  -> DIVI x CNUMW (intercept)
     -> FIN -> IDLE
  

A disabled output’s division state is removed at compile time, not skipped at run time. OUT_DV pulses for one clock when the tail COMPLETES - not when the N-th sample arrives - and both data outputs are 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 = 3 + \bigl(\mathrm{EN_{SLOPE}} + \mathrm{EN_{INTERCEPT}}\bigr) \cdot \mathrm{CNUMW} $$

with the divider width fixed at compile time by

$$ \mathrm{NBW} = \mathrm{IN_SW} + 2,\mathrm{MaxBlockExponent} + 5 , \qquad \mathrm{NAW} = \mathrm{IN_SW} + 2,\mathrm{MaxBlockExponent} + 4 $$

$$ \mathrm{CNUMW} = \max\bigl( \mathrm{NBW} + \mathrm{SLOPE_{fract}} + 4 ,; \mathrm{NAW} + \mathrm{INTERCEPT_{fract}} + 4 ,; \mathrm{SLOPE\ width} + 2 ,; \mathrm{INTERCEPT\ width} + 2 \bigr) $$

where $\mathrm{IN_SW}$ is the input width, plus one bit if the input is UNSIGNED, and the 4 is the guard SQG.

CNUMW has no EXP term: the tail does NOT depend on the runtime exponent. One divider serves both quotients, sized at the wider of the two - which also means that disabling an output halves the tail but does not narrow the divider: a slope-only placement is still sized against the intercept’s format if that one happens to be wider. Max Block Exponent does enter, at two clocks per unit, because it sizes the numerators.

Worked numbers link

Take a 16 bit signed input at the default formats (SLOPE Q8.16 signed, INTERCEPT Q16.8 signed, Max Block Exponent 20, both outputs enabled):

• $\mathrm{IN_SW} = 16$, so $\mathrm{NBW} = 16 + 40 + 5 = 61$ and $\mathrm{NAW} = 60$
• $\mathrm{CNUMW} = \max(61 + 16 + 4,; 60 + 8 + 4,; 24 + 2,; 24 + 2) = \max(81, 72, 26, 26) = 81$
• $L = 3 + 2 \cdot 81 = \mathbf{165}$ clocks, whatever EXP is
• the smallest exponent with $2^{\mathrm{EXP}} \ge 165$ is EXP = 8, i.e. N = 256

Turn the intercept off and the same configuration costs $L = 3 + 81 = 84$ clocks and works from EXP = 7 (N = 128).

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 two 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 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. If EXP is under software control, clamp it in software to the minimum the compiler printed. A drift measurement wants a long block anyway - fitting a line to 64 samples of a slow drift is mostly fitting the noise.

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

Three optional status outputs, all defaulting to NO. They answer different questions:

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 one or two divisions.
• 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 on this block it is also the N your SLOPE refers to when you go to convert it into units per second. Only RESET clears it to 0.

Q formats link

All three data ports carry their own fixed point format (integer bits, fractional bits, sign), the same convention as the Fixed P. family. Each quotient is requantised into its own format with the selected rounding (nearest / truncate) and overflow policy (saturate / wrap); saturation is symmetric for signed formats, as everywhere else in the toolchain.

Both outputs default to SIGNED, and both should stay that way for any real use: a drift can go either way, and a bipolar input can obviously have a negative intercept. See “UNITS” above for how to size them - it is the one place this block will surprise you.

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 solves the normal equations about the centred index in exact rational arithmetic and shares no algorithm with the core; the tolerance is 1 LSB on each output. Coverage includes a clean ramp - an exact fit, where the residual is zero and both outputs are exactly right, which is the strongest single check of the algebra - a ramp plus noise, a constant block (slope exactly 0, intercept the constant), pseudo-random input, a sine, slope-only and intercept-only placements to exercise the removed division and the changed port list, and a block-to-block alternating EXP to exercise the per-block latch of the exponent and both denominators. The tail length is checked at compile time: three copies of the formula exist

• the BLR_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.