Binary-16 Operation Part-II

FP16 Multiplication Decomposition

Finite FP16 multiplication is separated into sign calculation, exponent addition, significand multiplication, normalization, rounding, and packing.

SignA XOR SignB

How is the sign of an ordinary finite FP16 product calculated?

Add the two unbiased exponents.

How is the initial exponent of an FP16 product calculated?

22 bits

What width results from multiplying two 11-bit FP16 significands?

Because each unpacked normal FP16 operand contains an 11-bit working significand.

Why does ordinary FP16 significand multiplication produce a 22-bit intermediate product?

1.0 ≤ product < 4.0

If both normalized significands lie in the range 1.0 ≤ significand < 2.0, what range can their product occupy?

A product at least 2.0 requires a one-bit right normalization and an exponent increment.

Why can FP16 multiplication require right normalization even when both input significands were already normalized?

Product Precision Reduction

The conversion of the full 22-bit significand product into the extended significand format needed for FP16 normalization and rounding while preserving discarded information in sticky.

Product bits 21:8 are retained, while product bit 7 and bits 6:0 contribute to sticky.

How does the Proteus combinational multiplier reduce its 22-bit product for normalization?

11 iterations

How many shift-and-add iterations does the Proteus sequential FP16 multiplier require for ordinary finite significand multiplication?

The floating-point sign and exponent are determined separately, while the sequential multiplier iteratively forms the significand product.

How does the FP16 sequential multiplier divide the floating-point problem from the underlying shift-and-add multiplication problem?

Special multiplication cases can complete immediately without performing the 11 significand-multiplication iterations.

Why does the sequential FP16 multiplier check special cases before starting its iterative datapath?

FP16 Division Decomposition

Finite FP16 division separates the operation into sign calculation, operand-significand preparation, exponent subtraction, significand division, normalization, rounding, and packing.

SignA XOR SignB

How is the sign of an ordinary finite FP16 quotient calculated?

AdjustedExponentA - AdjustedExponentB

How is the initial exponent of an FP16 quotient calculated after its input significands have been normalized?

Division Input Renormalization

The preprocessing step in which a nonzero subnormal significand is shifted left until its leading 1 reaches the normal significand position, with its exponent decreased by the same shift count.

Division works with normalized finite nonzero significands, so a subnormal operand must first be transformed into that working form while preserving its value.

Why does the Proteus divider renormalize subnormal operands before significand division?

24 bits

What width does Proteus use for its fixed-point division numerator?

11 significand bits plus 13 additional fractional precision bits.

How is the 24-bit fixed-point numerator width for FP16 division obtained?

24 iterations

How many restoring-division iterations process the ordinary finite Proteus FP16 numerator?

Division Remainder as Sticky Information

A nonzero final division remainder indicates that additional quotient fraction bits beyond those explicitly calculated would contain nonzero information.

QuotientRegister[0] OR (remainder ≠ 0)

How does the Proteus divider form its quotient sticky bit?

FP16 Square-Root Exponent Rule

The floating-point square-root exponent is obtained by making the radicand exponent even and then dividing that exponent by two.

Because sqrt(2^e) = 2^(e/2), and an integer binary exponent must be made even before it can be halved exactly.

Why does the FP16 square-root datapath require special handling for an odd exponent?

Multiply the significand by two and decrease the exponent by one.

How does Proteus transform a radicand whose adjusted exponent is odd before taking its square root?

1.5 × 2^3 → 3.0 × 2^2

What example illustrates Proteus's odd-exponent adjustment before square root?

15 iterations

How many iterations does the Proteus FP16 square-root engine perform for its 30-bit internal radicand?

Two radicand bits.

How many radicand bits does the digit-by-digit square-root engine process during each iteration?

Square-Root Remainder as Sticky Information

A nonzero remainder after the calculated root bits indicates that additional fractional root bits would be nonzero and must influence rounding.

Positive

What sign is supplied to the rounder for every valid finite nonzero FP16 square-root result?