PTO-SCALAR-MODEL-FSU-ARITHMETIC

1// PTO-UNIT: {"id":"PTO-SCALAR-MODEL-FSU-ARITHMETIC","surface":"scalar","classification":["model","fsu","arithmetic"],"depends_on":["PTO-SCALAR-MODEL-SYS-REGISTERS","PTO-ARCH-DATA-TYPES-NUMERIC-CLASSIFICATION"]}2// PTO-REQ-SCALAR-FP-001: mathematical floating semantics.3// Encoding, NaN payload, exception flag, and rounding-profile rules remain4// separate from this real-number value layer.5
6pure func FloatingBinary(op: FloatingBinaryOperation, left: real, right: real) => real7begin8    case op of9        when FloatingBinary_ADD => return left + right;10        when FloatingBinary_SUB => return left - right;11        when FloatingBinary_MUL => return left * right;12        when FloatingBinary_DIV => return left / right;13        when FloatingBinary_MIN => if left < right then return left; else return right; end;14        when FloatingBinary_MAX => if left > right then return left; else return right; end;15    end;16end;17
18pure func FloatingCompare(op: FloatingCompareOperation, left: real, right: real) => boolean19begin20    case op of21        when FloatingCompare_EQ => return left == right;22        when FloatingCompare_NE => return left != right;23        when FloatingCompare_LT => return left < right;24        when FloatingCompare_LE => return left <= right;25        when FloatingCompare_GT => return left > right;26        when FloatingCompare_GE => return left >= right;27    end;28end;29
30impdef func FloatingExponential(value: real) => real31begin32    // The executable default is stable; a numeric profile supplies IEEE encoding.33    return value;34end;35
36func FloatingUnary(op: FloatingUnaryOperation, value: real) => real37begin38    case op of39        when FloatingUnary_ABS => if value < 0.0 then return -value; else return value; end;40        when FloatingUnary_SQRT =>41            assert value >= 0.0;42            return SqrtRounded(value, 100);43        when FloatingUnary_EXP => return FloatingExponential(value);44        when FloatingUnary_RECIP => return 1.0 / value;45    end;46end;47
48pure func FloatingFused(op: FloatingFusedOperation, addend: real,49                        left: real, right: real) => real50begin51    let product = left * right;52    case op of53        when FloatingFused_MADD => return product + addend;54        when FloatingFused_MSUB => return product - addend;55        when FloatingFused_NMADD => return -(product + addend);56        when FloatingFused_NMSUB => return -(product - addend);57    end;58end;59
60impdef func FloatingRoundNearest(value: real) => integer61begin62    if value >= 0.0 then return RoundDown(value + 0.5);63    else return RoundUp(value - 0.5);64    end;65end;66
67func FloatingToInteger(value: real, mode: NumericRoundingMode) => integer68begin69    case mode of70        when NumericRound_RNE => return FloatingRoundNearest(value);71        when NumericRound_RTP => return RoundUp(value);72        when NumericRound_RTM => return RoundDown(value);73        when NumericRound_RTZ => return RoundTowardsZero(value);74        when NumericRound_RNA =>75            let lower = RoundDown(value);76            let fraction = value - Real(lower);77            if fraction < 0.5 then return lower;78            elsif fraction > 0.5 then return lower + 1;79            elsif value < 0.0 then return lower;80            else return lower + 1;81            end;82        when NumericRound_RTO =>83            let lower = RoundDown(value);84            let fraction = value - Real(lower);85            if fraction == 0.0 then return lower;86            elsif lower MOD 2 != 0 then return lower;87            else return lower + 1;88            end;89        when NumericRound_RHB =>90            let lower = RoundDown(value);91            let fraction = value - Real(lower);92            if fraction < 0.5 then return lower;93            else return lower + 1;94            end;95    end;96end;97
98pure func ResolveScalarFPActiveRoundingMode(encoded: bits(3))99                                                => NumericRoundingMode100begin101    if encoded == '001' then return NumericRound_RTM;102    elsif encoded == '010' then return NumericRound_RTP;103    elsif encoded == '011' then return NumericRound_RTZ;104    else return NumericRound_RNE;105    end;106end;107
108pure func DecodeBundleRoundingSelection(encoded: bits(3))109                                                => TileNumericSelection110begin111    var result = TileNumericSelection {112        use_operation_default = encoded == '000',113        rounding_mode = NumericRound_RNE,114        saturating = FALSE115    };116    if encoded == '010' then result.rounding_mode = NumericRound_RTZ;117    elsif encoded == '011' then result.rounding_mode = NumericRound_RTM;118    elsif encoded == '100' then result.rounding_mode = NumericRound_RTP;119    elsif encoded == '101' then result.rounding_mode = NumericRound_RNA;120    elsif encoded == '110' then result.rounding_mode = NumericRound_RTO;121    elsif encoded == '111' then result.rounding_mode = NumericRound_RHB;122    end;123    return result;124end;125
126// Public conversion controls are not B.DATR encodings. Translate the seven127// assigned public ordinals explicitly; ordinal 7 is unassigned.128pure func DecodePublicConversionRoundingSelection(encoded: bits(3))129                                                => (boolean, TileNumericSelection)130begin131    if encoded == '000' then return (TRUE, DecodeBundleRoundingSelection('000'));132    elsif encoded == '001' then return (TRUE, DecodeBundleRoundingSelection('001'));133    elsif encoded == '010' then return (TRUE, DecodeBundleRoundingSelection('101'));134    elsif encoded == '011' then return (TRUE, DecodeBundleRoundingSelection('011'));135    elsif encoded == '100' then return (TRUE, DecodeBundleRoundingSelection('100'));136    elsif encoded == '101' then return (TRUE, DecodeBundleRoundingSelection('010'));137    elsif encoded == '110' then return (TRUE, DecodeBundleRoundingSelection('110'));138    else return (FALSE, DecodeBundleRoundingSelection('000'));139    end;140end;141
142pure func SignedWordToReal(value: Word) => real143begin144    return Real(SInt(value));145end;146
147pure func UnsignedWordToReal(value: Word) => real148begin149    return Real(UInt(value));150end;151
152func ConvertFloatingEncoding(value: Word, source_type: bits(5),153                             destination_type: bits(5),154                             rounding_mode: bits(3)) => Word155begin156    let (converted, -) = ScalarFPConvertProfile(157        ResolveScalarFPActiveRoundingMode(rounding_mode),158        destination_type, source_type, value);159    return converted;160end;161