package dolmen

  1. Overview
  2. Docs

Module Builtin.FloatSource

Sourcetype rounding_mode =
  1. | RoundNearestTiesToEven
    (*

    RoundNearestTiesToEven : RoundingMode:

    *)
  2. | RoundNearestTiesToAway
    (*

    RoundNearestTiesToAway : RoundingMode:

    *)
  3. | RoundTowardPositive
    (*

    RoundTowardPositive : RoundingMode

    *)
  4. | RoundTowardNegative
    (*

    RoundTowardNegative : RoundingMode

    *)
  5. | RoundTowardZero
    (*

    RoundTowardZero : RoundingMode

    *)
Sourcetype _ t =
  1. | T of {
    1. e : int;
    2. s : int;
    }
    (*

    Float(e,s): ttype: type constructor for floating point of exponent of size e and significand of size s (hidden bit included). Those size are greater than 1

    *)
  2. | RoundingMode
    (*

    RoundingMode: ttype: type for enumerated type of rounding modes.

    *)
  3. | RM of rounding_mode
    (*

    RM r: RoundingMode: rounding mode literals.

    *)
  4. | Fp of {
    1. e : int;
    2. s : int;
    }
    (*

    Fp(e, s): Bitv.T{1} -> Bitv.T{e} -> Bitv.T{s-1} -> Fp(e,s): bitvector literal. The IEEE-format is used for the conversion sb^se^ss. All the NaN are converted to the same value.

    *)
  5. | Plus_infinity of {
    1. e : int;
    2. s : int;
    }
    (*

    Plus_infinity{e;s} : Fp{e;s}

    *)
  6. | Minus_infinity of {
    1. e : int;
    2. s : int;
    }
    (*

    Minus_infinity{e;s} : Fp{e;s}

    *)
  7. | Plus_zero of {
    1. e : int;
    2. s : int;
    }
    (*

    Plus_zero{e;s} : Fp{e;s}

    *)
  8. | Minus_zero of {
    1. e : int;
    2. s : int;
    }
    (*

    Minus_zero{e;s} : Fp{e;s}

    *)
  9. | NaN of {
    1. e : int;
    2. s : int;
    }
    (*

    NaN{e;s} : Fp{e;s}

    *)
  10. | Abs of {
    1. e : int;
    2. s : int;
    }
    (*

    abs{e;s}: Fp{e;s} -> Fp{e;s}: absolute value

    *)
  11. | Neg of {
    1. e : int;
    2. s : int;
    }
    (*

    neg{e;s}: Fp{e;s} -> Fp{e;s}: negation

    *)
  12. | Add of {
    1. e : int;
    2. s : int;
    }
    (*

    add{e;s}: RoundingMode -> Fp{e;s} -> Fp{e;s} -> Fp{e;s}: addition

    *)
  13. | Sub of {
    1. e : int;
    2. s : int;
    }
    (*

    Sub{e;s}: RoundingMode -> Fp{e;s} -> Fp{e;s} -> Fp{e;s}: subtraction

    *)
  14. | Mul of {
    1. e : int;
    2. s : int;
    }
    (*

    Mul{e;s}: RoundingMode -> Fp{e;s} -> Fp{e;s} -> Fp{e;s}: multiplication

    *)
  15. | Div of {
    1. e : int;
    2. s : int;
    }
    (*

    Div{e;s}: RoundingMode -> Fp{e;s} -> Fp{e;s} -> Fp{e;s}: division

    *)
  16. | Fma of {
    1. e : int;
    2. s : int;
    }
    (*

    Fma{e:s}: RoundingMode -> Fp{e;s} -> Fp{e;s}: fuse multiply add

    *)
  17. | Sqrt of {
    1. e : int;
    2. s : int;
    }
    (*

    Sqrt{e;s}: RoundingMode -> Fp{e;s} -> Fp{e;s}: square root

    *)
  18. | Rem of {
    1. e : int;
    2. s : int;
    }
    (*

    Rem{e;s}: Fp{e;s} -> Fp{e;s} -> Fp{e;s}: remainder

    *)
  19. | RoundToIntegral of {
    1. e : int;
    2. s : int;
    }
    (*

    RoundToIntegral{e;s}: RoundingMode -> Fp{e;s} -> Fp{e;s}: round to integral

    *)
  20. | Min of {
    1. e : int;
    2. s : int;
    }
    (*

    Min{e;s}: Fp{e;s} -> Fp{e;s} -> Fp{e;s}: minimum

    *)
  21. | Max of {
    1. e : int;
    2. s : int;
    }
    (*

    Max{e;s}: Fp{e;s} -> Fp{e;s} -> Fp{e;s}: maximum

    *)
  22. | Leq of {
    1. e : int;
    2. s : int;
    }
    (*

    Leq{e;s}: Fp{e;s} -> Fp{e;s} -> Prop.T: IEEE less or equal

    *)
  23. | Lt of {
    1. e : int;
    2. s : int;
    }
    (*

    Lt{e;s}: Fp{e;s} -> Fp{e;s} -> Prop.T: IEEE less than

    *)
  24. | Geq of {
    1. e : int;
    2. s : int;
    }
    (*

    Geq{e;s}: Fp{e;s} -> Fp{e;s} -> Prop.T: IEEE greater or equal

    *)
  25. | Gt of {
    1. e : int;
    2. s : int;
    }
    (*

    Gt{e;s}: Fp{e;s} -> Fp{e;s} -> Prop.T: IEEE greater than

    *)
  26. | Eq of {
    1. e : int;
    2. s : int;
    }
    (*

    Eq(s,e): Fp(s,e) -> Fp(s,e) -> Prop.T: IEEE equality

    *)
  27. | IsNormal of {
    1. e : int;
    2. s : int;
    }
    (*

    IsNormal{e;s}: Fp{e;s} -> Prop.T: test if it is a normal floating point

    *)
  28. | IsSubnormal of {
    1. e : int;
    2. s : int;
    }
    (*

    IsSubnormal{e;s}: Fp{e;s} -> Prop.T: test if it is a subnormal floating point

    *)
  29. | IsZero of {
    1. e : int;
    2. s : int;
    }
    (*

    IsZero{e;s}: Fp{e;s} -> Prop.T: test if it is a zero

    *)
  30. | IsInfinite of {
    1. e : int;
    2. s : int;
    }
    (*

    IsInfinite{e;s}: Fp{e;s} -> Prop.T: test if it is an infinite

    *)
  31. | IsNaN of {
    1. e : int;
    2. s : int;
    }
    (*

    IsNaN{e;s}: Fp{e;s} -> Prop.T: test if it is Not a Number

    *)
  32. | IsNegative of {
    1. e : int;
    2. s : int;
    }
    (*

    IsNegative{e;s}: Fp{e;s} -> Prop.T: test if it is negative

    *)
  33. | IsPositive of {
    1. e : int;
    2. s : int;
    }
    (*

    IsPositive{e;s}: Fp{e;s} -> Prop.T: test if it is positive

    *)
  34. | Ieee_format_to_fp of {
    1. e : int;
    2. s : int;
    }
    (*

    Ieee_format_to_fp{e;s}: Bv{n=s+e} -> Fp{e;s}: Convert from IEEE interchange format

    *)
  35. | To_fp of {
    1. e1 : int;
    2. s1 : int;
    3. e2 : int;
    4. s2 : int;
    }
    (*

    To_fp{e1;s1;e2;s2}: RoundingMode -> Fp{e1;s2} -> Fp{e2;s2}: Convert from another floating point format

    *)
  36. | Of_real of {
    1. e : int;
    2. s : int;
    }
    (*

    Of_real{e;s}: RoundingMode -> Real -> Fp{e;s}: Convert from a real

    *)
  37. | Of_sbv of {
    1. m : int;
    2. e : int;
    3. s : int;
    }
    (*

    Of_sbv{m;e;s}: RoundingMode -> Bitv.T{n=m} -> Fp{e;s}: Convert from a signed integer

    *)
  38. | Of_ubv of {
    1. m : int;
    2. e : int;
    3. s : int;
    }
    (*

    Of_ubv{m;e;s}: RoundingMode -> Bitv.T{n=m} -> Fp{e;s}: Convert from a unsigned integer

    *)
  39. | To_ubv of {
    1. m : int;
    2. e : int;
    3. s : int;
    }
    (*

    To_ubv{m;e;s}: RoundingMode -> Fp{e;s} -> Bitv.T{n=m}: Convert to an unsigned integer

    *)
  40. | To_sbv of {
    1. m : int;
    2. e : int;
    3. s : int;
    }
    (*

    To_sbv{m;e;s}: RoundingMode -> Fp{e;s} -> Bitv.T{n=m}: Convert to an signed integer

    *)
  41. | To_real of {
    1. e : int;
    2. s : int;
    }
    (*

    To_real{e;s}: Fp{e;s} -> Real: Convert to real

    *)