PTO-ARCH-DATA-TYPES-FP19

1// PTO-UNIT: {"id":"PTO-ARCH-DATA-TYPES-FP19","surface":"arch","classification":["data-types","fp19"],"depends_on":["PTO-ARCH-DATA-TYPES-NUMERIC-CLASSIFICATION"]}2// FP19 is the architectural scalar/vector parameter carrier used by B.FPATR.3// NDF-BEGIN: PTO-FP19-PARAMETER-CARRIER-0014// ndf: kind=contract level=L1 layer=architecture status=accepted5// FP19 MUST use one sign bit, an eight-bit bias-127 exponent, and a ten-bit6// fraction. B.FPATR scales MUST be positive normal values; activation7// parameters MUST be positive zero or positive normal values. Subnormal and8// non-finite FP19 parameter carriers are illegal before architectural effects.9// NDF-END: PTO-FP19-PARAMETER-CARRIER-00110
11pure func FP19PowerOfTwo(exponent: integer {-136..127}) => real12begin13    var result: real = 1.0;14    if exponent > 0 then15        for step = 1 to exponent looplimit 127 do16            result = result * 2.0;17        end;18    elsif exponent < 0 then19        for step = 1 to -exponent looplimit 136 do20            result = result / 2.0;21        end;22    end;23    return result;24end;25
26pure func FP19ValueClass(value: bits(19)) => NumericValueClass27begin28    let exponent = value[17:10];29    let fraction = value[9:0];30    if exponent == Ones{8} then31        if fraction == Zeros{10} then32            if value[18] == '1' then33                return NumericValue_NegativeInfinity;34            else35                return NumericValue_PositiveInfinity;36            end;37        elsif fraction[9] == '1' then38            return NumericValue_QuietNaN;39        else40            return NumericValue_SignalingNaN;41        end;42    end;43    return NumericValueClassFromFiniteSign(44        value[18],45        exponent == Zeros{8} && fraction == Zeros{10},46        exponent == Zeros{8} && fraction != Zeros{10});47end;48
49pure func FP19FiniteValue(value: bits(19)) => real50begin51    let exponent = UInt(value[17:10]);52    let fraction = UInt(value[9:0]);53    assert exponent != 255;54    var magnitude: real = 0.0;55    if exponent == 0 then56        magnitude = Real(fraction) * FP19PowerOfTwo(-136);57    else58        magnitude = (1.0 + Real(fraction) / 1024.0) *59            FP19PowerOfTwo((exponent - 127) as integer {-126..127});60    end;61    if value[18] == '1' then return -magnitude; end;62    return magnitude;63end;64
65pure func FP19ScaleLegal(value: bits(19)) => boolean66begin67    return FP19ValueClass(value) == NumericValue_PositiveNormal;68end;69
70pure func FP19ActivationParameterLegal(value: bits(19)) => boolean71begin72    let value_class = FP19ValueClass(value);73    return value_class == NumericValue_PositiveZero ||74           value_class == NumericValue_PositiveNormal;75end;76
77pure func FP32ToFP19(value: Word) => bits(19)78begin79    let source = value[31:0];80    let source_class = ClassifyFP32(source);81    if NumericValueClassIsNaN(source_class) then82        return '0111111111100000000';83    end;84    var exponent: integer {0..256} = UInt(source[30:23]);85    var fraction: integer {0..1024} = UInt(source[22:13]);86    let discarded = UInt(source[12:0]);87    let halfway = 0x1000;88    if discarded > halfway ||89       (discarded == halfway && fraction MOD 2 == 1) then90        assert fraction <= 1023;91        fraction = (fraction + 1) as integer {0..1024};92        if fraction == 0x400 then93            fraction = 0;94            if exponent < 255 then95                exponent = (exponent + 1) as integer {0..256};96            end;97        end;98    end;99    var result = Zeros{19};100    assert exponent <= 255;101    assert fraction <= 1023;102    result[18] = source[31];103    result[17:10] = Zeros{8} + (exponent as integer {0..255});104    result[9:0] = Zeros{10} + (fraction as integer {0..1023});105    return result;106end;107