bin_float API

bin_float 是 floating 的二进制浮点核心。BinFloat 是一个带符号的二进有理数 $(-1)^s \cdot c \cdot 2^{e}$ ，具有任意精度的系数、附带的工作精度，以及 IEEE 754 特殊值（带符号零、无穷、带 payload 的静默 NaN 和信号 NaN）。每个算术运算都对精确结果只舍入一次。BinaryContext 给出单次运算的精度、指数范围、舍入方向和微小性（tininess）规则，*_ctx 方法在返回值的同时返回 IEEE 状态标志。教程展示常见工作流程，设计文档推导下文所用的舍入、范围与认证规则。经过验证的 IEEE 754 范围列于符合性页面。

在 moon.pkg 中导入该包：

import {
  "Luna-Flow/floating/bin_float",
}

本页中， $p$ 表示以位为单位的精度， $\circ(x)$ 表示实数 $x$ 在当前上下文下的舍入结果，“标志”指 BinaryFlags 值中的五个 IEEE 异常标志。@lf_arith 即 Luna-Flow/arithmetic 包；其 RoundingMode、ArithmeticContext 和 ArithmeticError 类型出现在若干签名中（接口文件将该包打印为 @arithmetic）。

调用运算的三种方式

大多数运算最多有三种形式，背后是同一个数值算法。

形式	示例	上下文	结果
普通	`x + y`, `x.exp()`	无界指数范围、就近舍入（偶数优先）、操作数的精度	仅返回值
上下文式	`x.add_ctx(y, ctx)`, `x.exp_ctx(ctx)`	给定的 `BinaryContext`	`(value, flags)`
checked	`x.try_exp_ctx(ctx)`, `x.div_checked(y)`	给定的上下文，或普通形式的上下文	带 `@lf_arith.ArithmeticError` 的 `Result`

二元运算的普通形式以两个操作数中较大的精度工作（对 fma 为三者中最大的）。其指数范围为下文所述的实现范围，因此只有在约 $2^{\pm 2^{30}}$ 时才会上溢为无穷或下溢为带符号零或极小值。

值与限制

`binary_implementation_e_max`, `binary_implementation_e_min`

有限 BinFloat 的最高位所能具有的最大和最小指数。

pub let binary_implementation_e_max : Int
pub let binary_implementation_e_min : Int

它们是 $2^{30}-1 = 1073741823$ 和 $-(2^{30}-1)$ 。无界上下文以及每个普通运算都以它们作为 $e_{\max}$ 和 $e_{\min}$ ：最高位将位于 $e_{\max}$ 之上的结果发生上溢，而在 $e_{\min}$ 之下的值是量子为 $2^{e_{\min}-p+1}$ 的次正规数。带有显式边界的上下文会与该范围取交。

`binary_precision_max`

BinaryContext 所接受的最大精度。

pub let binary_precision_max : Int

它是 $2^{28} = 268435456$ 位。连同指数范围，它保证每个系数指数都在 32 位 Int 范围之内。

精确系数

`BinCoeff`

一个非负的任意精度整数，用作 BinFloat 的系数以及交换编码的位模式。

pub struct BinCoeff {
  // private fields
} derive(@debug.Debug)

BinCoeff 上的所有算术都是精确的。在 native、LLVM 和 Wasm 目标上，该值是内联的 64 位或 128 位字，或 32 位 limb 数组；在 JavaScript 上则是宿主的 bigint。表示方式不可观察，算法选择（教科书算法、Karatsuba、Toom-3、数论变换、分阶段除法）见设计文档。数学结果可能为负或无定义的运算会进行检查，并以带消息的 Err 代替返回。

`BinCoeff::zero`, `BinCoeff::one`, `BinCoeff::from_uint64`

由机器值构建系数。

pub fn BinCoeff::zero() -> Self
pub fn BinCoeff::one() -> Self
pub fn BinCoeff::from_uint64(UInt64) -> Self

`BinCoeff::parse`, `BinCoeff::to_string`, `BinCoeff::to_radix_string`

在系数与数字串之间转换。

pub fn BinCoeff::parse(String, radix? : Int) -> Result[Self, String]
pub fn BinCoeff::to_string(Self) -> String
pub fn BinCoeff::to_radix_string(Self, Int) -> String

parse 读取以 radix 为基数的数字串（默认 10，大于 9 的数字用字母表示，可带一个前导 +）；空串、- 号、超出基数的数字或不在 $[2, 36]$ 内的基数均为 Err。to_string 输出十进制，to_radix_string 输出 $[2, 36]$ 内任意基数，使用小写且不带前缀；对其他基数它会中止。

`BinCoeff::from_bytes_be`, `BinCoeff::to_bytes_be`

在系数与大端字节序列之间转换。

pub fn BinCoeff::from_bytes_be(BytesView) -> Self
pub fn BinCoeff::to_bytes_be(Self) -> Bytes

to_bytes_be 使用最少的字节数；from_bytes_be 忽略前导零字节。

`BinCoeff::to_uint64`

以 UInt64 返回该值；若需要多于 64 位则返回 None。

pub fn BinCoeff::to_uint64(Self) -> UInt64?

`BinCoeff::is_zero`, `BinCoeff::bit_length`, `BinCoeff::ctz`, `BinCoeff::test_bit`

位级查询。

pub fn BinCoeff::is_zero(Self) -> Bool
pub fn BinCoeff::bit_length(Self) -> Int
pub fn BinCoeff::ctz(Self) -> Int
pub fn BinCoeff::test_bit(Self, Int) -> Bool

对 $c > 0$ ，bit_length 为 $\lfloor \log_2 c \rfloor + 1$ ，对零为 $0$ 。ctz 统计末尾零位的个数（即 2-adic 赋值 $\nu_2(c)$ ）。test_bit(i) 是第 $i$ 位，从最低有效位 $0$ 开始计数。

`BinCoeff::compare`, `BinCoeff::equal`

精确比较。

pub fn BinCoeff::compare(Self, Self) -> Int
pub fn BinCoeff::equal(Self, Self) -> Bool
pub fn BinCoeff::not_equal(Self, Self) -> Bool
pub fn BinCoeff::op_lt(Self, Self) -> Bool
pub fn BinCoeff::op_le(Self, Self) -> Bool
pub fn BinCoeff::op_gt(Self, Self) -> Bool
pub fn BinCoeff::op_ge(Self, Self) -> Bool

compare 返回 $-1$ 、 $0$ 或 $1$ 。运算符方法是提升到该类型上的 Compare 和 Eq trait 方法；请使用运算符 <、== 等。

`BinCoeff::add`, `BinCoeff::mul`, `BinCoeff::square`, `BinCoeff::pow_nat`

精确的加法、乘法、平方与幂。

pub fn BinCoeff::add(Self, Self) -> Self
pub fn BinCoeff::mul(Self, Self) -> Self
pub fn BinCoeff::square(Self) -> Self
pub fn BinCoeff::pow_nat(Self, UInt) -> Self

square 使用专门的内核，利用交叉乘积的对称性。pow_nat(0) 为一，包括 $0^0$ 。

`BinCoeff::sub_checked`, `BinCoeff::div_rem_checked`

减法与欧几里得除法，在自然数上可能失败。

pub fn BinCoeff::sub_checked(Self, Self) -> Result[Self, String]
pub fn BinCoeff::div_rem_checked(Self, Self) -> Result[(Self, Self), String]

当 $b > a$ 时，a.sub_checked(b) 为 Err。n.div_rem_checked(d) 返回满足 $n = qd + r$ 且 $0 \le r < d$ 的 $(q, r)$ ，当 $d = 0$ 时为 Err。

`BinCoeff::gcd`

返回最大公约数。

pub fn BinCoeff::gcd(Self, Self) -> Self

$\gcd(a, 0) = a$ ， $\gcd(0, 0) = 0$ 。

`BinCoeff::shift_left`, `BinCoeff::shift_right`, `BinCoeff::shl`, `BinCoeff::shr`

乘以 $2^k$ ，或除以 $2^k$ 并向零舍入。

pub fn BinCoeff::shift_left(Self, Int) -> Self
pub fn BinCoeff::shift_right(Self, Int) -> Self
pub fn BinCoeff::shl(Self, Int) -> Self
pub fn BinCoeff::shr(Self, Int) -> Self

shl 和 shr 是 << 与 >> 背后的 Shl/Shr trait 方法。负的移位计数会中止。

`BinCoeff::bit_and`, `BinCoeff::bit_or`, `BinCoeff::bit_xor`

对二进制展开进行按位运算。

pub fn BinCoeff::bit_and(Self, Self) -> Self
pub fn BinCoeff::bit_or(Self, Self) -> Self
pub fn BinCoeff::bit_xor(Self, Self) -> Self

`BinCoeff` 的 trait 实现

BinCoeff 实现了 Add、Mul、Shl、Shr、Eq、Compare、Show 和 Debug。output 和 to_repr 是被提升的 Show 和 Debug 方法。

pub fn BinCoeff::output(Self, &Logger) -> Unit
pub fn BinCoeff::to_repr(Self) -> @debug.Repr
pub impl Add for BinCoeff
pub impl Compare for BinCoeff
pub impl Eq for BinCoeff
pub impl Mul for BinCoeff
pub impl Shl for BinCoeff
pub impl Show for BinCoeff
pub impl Shr for BinCoeff

///|
test "BinCoeff is exact natural-number arithmetic" {
  let c = @bin_float.BinCoeff::parse("ff", radix=16).unwrap()
  let ten = @bin_float.BinCoeff::from_uint64(10UL)
  let (q, r) = c.div_rem_checked(ten).unwrap()
  inspect("\{q} \{r} \{c.gcd(ten)} \{c.bit_length()}", content="25 5 5 8")
  inspect(ten.pow_nat(20), content="100000000000000000000")
  inspect(ten.sub_checked(c) is Err(_), content="true")
}

值类型

`BinFloat`

二进制浮点值：有限二进有理数、带符号无穷或 NaN，并带有工作精度。

pub struct BinFloat {
  // private fields
} derive(Eq, @debug.Debug)

有限值为 $(-1)^s \cdot c \cdot 2^{e}$ ，其中 $s$ 为符号位， $c$ 为 BinCoeff， $e$ = exponent2()。通过本 API 构建的每个值都是规范化的：非零的 $c$ 是奇数（2 的因子移入 $e$ ），零具有 $c = 0$ 和 $e = 0$ 并保留其符号，且 $c$ 至多有 precision() 位。精度是值的属性：普通运算以其操作数中较大的精度工作，上下文式运算则将上下文精度标记到结果上。

派生的 Eq 是结构相等，而不是数值相等。只有当符号、类别、系数、指数、精度和 NaN 状态全部一致时，两个值才 ==，因此 one(precision=53) != one(precision=24)，-0 != +0，而一个 NaN 与完全相同的 NaN ==。数值问题请使用 compare、compare_quiet 或 total_order。

`BinFloat::make`

构建舍入到 precision 位的有限值 $(-1)^{\text{negative}} \cdot c \cdot 2^{e}$ 。

pub fn BinFloat::make(BinCoeff, Int, Int, negative? : Bool, mode? : @arithmetic.RoundingMode) -> Self

参数为系数、指数 $e$ 和精度。当系数的有效位多于精度时，按 mode（默认 ToNearestEven）舍入。结果是规范化的。小于 1 的精度按 1 处理。超出实现指数范围的值会按 mode 变为无穷或零，与上溢或下溢的处理相同。

`BinFloat::from_coefficient`, `BinFloat::from_int`

由整数构建值。

pub fn BinFloat::from_coefficient(BinCoeff, precision? : Int, negative? : Bool) -> Self
pub fn BinFloat::from_int(Int, precision? : Int) -> Self

默认精度为 53。当整数的有效位多于精度时，按就近舍入（偶数优先）处理；在默认精度下，from_int(n) 对每个 Int 都是精确的。

`BinFloat::from_double`, `BinFloat::from_float`

精确解码宿主的 binary64 或 binary32 值。

pub fn BinFloat::from_double(Double, precision? : Int) -> Self
pub fn BinFloat::from_float(Float, precision? : Int) -> Self

默认值分别为 53 和 24 位，因此转换是精确的。带符号零、无穷、NaN 的符号、静默/信号的区分以及 NaN payload 均被保留。该值是宿主已经舍入过的值：from_double(0.1) 是 $3602879701896397 \cdot 2^{-55}$ ，而不是十分之一。要直接舍入一个十进制字面量，请使用 from_string。

`BinFloat::zero`, `BinFloat::negative_zero`, `BinFloat::one`, `BinFloat::inf`

构建常量 $+0$ 、 $-0$ 、 $1$ 和 $\pm\infty$ 。

pub fn BinFloat::zero(precision? : Int) -> Self
pub fn BinFloat::negative_zero(precision? : Int) -> Self
pub fn BinFloat::one(precision? : Int) -> Self
pub fn BinFloat::inf(@def.Sign, precision? : Int) -> Self

默认精度为 53。inf(Sign::Negative) 为 $-\infty$ ；任何其他符号都给出 $+\infty$ 。

`BinFloat::nan`, `BinFloat::quiet_nan`, `BinFloat::signaling_nan`

构建 NaN。

pub fn BinFloat::nan(precision? : Int) -> Self
pub fn BinFloat::quiet_nan(payload? : BinCoeff, negative? : Bool, precision? : Int) -> Self
pub fn BinFloat::signaling_nan(payload? : BinCoeff, negative? : Bool, precision? : Int) -> Self

nan() 是 payload 为 0 的正静默 NaN。信号 NaN 的 payload 总是非零（默认值和请求的 0 都会变为 1）。payload 在运算中传递，仅当值被编码为交换格式时才被截断到 payload 字段。

观察值

`BinFloat::classify`, `BinFloat::sign`, `BinFloat::is_negative`

报告值的类别和符号。

pub fn BinFloat::classify(Self) -> @arithmetic.FpClass
pub fn BinFloat::sign(Self) -> @def.Sign
pub fn BinFloat::is_negative(Self) -> Bool

classify 返回 Finite、Infinity 或 NaN（零属于 Finite）。sign 对所有零和所有 NaN 为 Zero，否则为 Positive 或 Negative。is_negative 返回符号位本身，它对 $-0$ 、 $-\infty$ 和负 NaN 是置位的。@def.is_finite、@def.is_nan、@def.is_infinite 和 @def.is_zero 通过 Floating trait 作用于 BinFloat。

`BinFloat::is_zero`, `BinFloat::is_negative_zero`, `BinFloat::is_quiet_nan`, `BinFloat::is_signaling_nan`, `BinFloat::nan_payload`

特殊值谓词。

pub fn BinFloat::is_zero(Self) -> Bool
pub fn BinFloat::is_negative_zero(Self) -> Bool
pub fn BinFloat::is_quiet_nan(Self) -> Bool
pub fn BinFloat::is_signaling_nan(Self) -> Bool
pub fn BinFloat::nan_payload(Self) -> BinCoeff

对非 NaN 的值，nan_payload 为零。

`BinFloat::coefficient`, `BinFloat::exponent2`, `BinFloat::precision`

返回存储的表示。

pub fn BinFloat::coefficient(Self) -> BinCoeff
pub fn BinFloat::exponent2(Self) -> Int
pub fn BinFloat::precision(Self) -> Int

对有限值，其数值为 coefficient() $\times 2^{\texttt{exponent2()}}$ 再带上符号。无穷或 NaN 的系数和指数没有意义。

`BinFloat::normalized`

返回有限值在其自身精度下的规范表示。

pub fn BinFloat::normalized(Self) -> Self

通过公共 API 构建的值已经是规范的，因此对它们而言这是恒等操作；无穷和 NaN 原样返回。

`BinFloat::with_precision`

将值舍入到新的工作精度。

pub fn BinFloat::with_precision(Self, Int, @arithmetic.RoundingMode) -> Self

有效位多于新精度的有限值按给定方向舍入（@lf_arith.RoundingMode 没有 ties-to-away 模式；如需该模式请使用 round_ctx）。零、无穷和 NaN 只改变其精度属性。不报告标志；需要标志时请使用 round_ctx。

`BinFloat::ulp`

返回有限值在其自身精度下的最后一位单位（ulp）。

pub fn BinFloat::ulp(Self) -> Self

对于 $x \ne 0$ ，记最高位指数为 $t = \lfloor \log_2 |x| \rfloor$ ，结果为 $2^{t-p+1}$ 。对零为 $2^{1-p}$ ，对无穷或 NaN 为静默 NaN。该间距忽略任何上下文指数范围，因此它不是 IEEE 格式中的次正规间距。

///|
test "make normalizes and rounds to the precision" {
  let twelve = @bin_float.BinFloat::make(
    @bin_float.BinCoeff::from_uint64(12UL),
    0,
    2,
  )
  inspect(
    "\{twelve} \{twelve.coefficient()} \{twelve.exponent2()}",
    content="3p2 3 2",
  )
  // 13 needs four bits; at two bits it rounds to nearest-even 12.
  let thirteen = @bin_float.BinFloat::make(
    @bin_float.BinCoeff::from_uint64(13UL),
    0,
    2,
  )
  inspect(thirteen, content="3p2")
  inspect(@bin_float.BinFloat::one().ulp(), content="1p-52")
}

普通算术

`BinFloat::add`, `BinFloat::sub`, `BinFloat::mul`, `BinFloat::div`, `BinFloat::neg`

四则运算与取负，也可以通过 +、-、*、/ 和一元 - 使用。

pub fn BinFloat::add(Self, Self) -> Self
pub fn BinFloat::sub(Self, Self) -> Self
pub fn BinFloat::mul(Self, Self) -> Self
pub fn BinFloat::div(Self, Self) -> Self
pub fn BinFloat::neg(Self) -> Self
pub impl Add for BinFloat
pub impl Sub for BinFloat
pub impl Mul for BinFloat
pub impl Div for BinFloat
pub impl Neg for BinFloat

结果是精确的和、差、积或商，以较大的操作数精度、在实现指数范围内就近舍入（偶数优先）一次。特殊值遵循 IEEE 754：NaN 会传播（取第一个 NaN 操作数并静默化）， $\infty - \infty$ 、 $0 \cdot \infty$ 、 $0/0$ 和 $\infty/\infty$ 为 NaN，非零数除以零得到带符号无穷。标志被丢弃；要观察标志请使用上下文式形式。neg 翻转每个值的符号位，包括零和 NaN，并且从不舍入。

`BinFloat::abs`, `BinFloat::copy_sign`

清除或复制符号位。

pub fn BinFloat::abs(Self) -> Self
pub fn BinFloat::copy_sign(Self, Self) -> Self

二者都是静默的 IEEE 符号位运算：从不舍入，从不触发标志，并保留 NaN payload。x.copy_sign(y) 具有 x 的绝对值和 y 的符号位。

`BinFloat::div_checked`

做除法，除数为零时返回错误。

pub fn BinFloat::div_checked(Self, Self) -> Result[Self, @arithmetic.ArithmeticError]

有限的零除数（包括 $0/0$ ）给出 division_by_zero 错误。否则结果与 div 相同。

`BinFloat::sqrt`, `sqrt_for_precision`, `sqrt_bounds_for_precision`

正确舍入的平方根。

pub fn BinFloat::sqrt(Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn sqrt_for_precision(BinFloat, Int) -> Result[BinFloat, @arithmetic.ArithmeticError]
pub fn sqrt_bounds_for_precision(BinFloat, Int) -> Result[(BinFloat, BinFloat), @arithmetic.ArithmeticError]

x.sqrt() 以 x 的精度将 $\sqrt{x}$ 就近舍入（偶数优先）；sqrt_for_precision(x, p) 在精度 p 下做同样的事。对负的非零参数（包括 $-\infty$ 和符号位置位的 NaN），二者都返回 domain_error； $\sqrt{-0} = -0$ ，正 NaN 给出静默 NaN 的 Ok。sqrt_bounds_for_precision(x, p) 返回 $(\operatorname{RD}_p(\sqrt x), \operatorname{RU}_p(\sqrt x))$ ，这是一个宽度至多为一个 ulp 的包络，当平方根精确时退化为一个点。它需要有限的非负参数：NaN 或无穷为 unsupported，负值为 domain_error。

`BinFloat::pow_int`, `BinFloat::pown`

计算值的整数次幂。

pub fn BinFloat::pow_int(Self, Int) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BinFloat::pown(Self, Int) -> Result[Self, @arithmetic.ArithmeticError]

这两个名字是同一个函数。结果是以 x 的精度就近舍入（偶数优先）的正确舍入 $x^n$ ，计算方式同 pow_int_ctx。零底数配负指数为 division_by_zero 错误；对任意 $x$ （包括 NaN）， $x^0 = 1$ 。

`BinFloat::fma`

融合乘加：只舍入一次的 $x \cdot y + z$ 。

pub fn BinFloat::fma(Self, Self, Self) -> Self

精度为三个操作数精度中的最大者。特殊情形参见 fma_ctx。

`BinFloat::remainder`

IEEE 754 余数 $x - n y$ ，其中 $n$ 是最接近 $x/y$ 的整数，平局时取偶数。

pub fn BinFloat::remainder(Self, Self) -> Self

只要结果能以较大的操作数精度表示，它就是精确的；对于该精度的操作数，这总是成立（证明见设计文档）。参见 remainder_ctx。

///|
test "plain arithmetic rounds once at the operand precision" {
  let one = @bin_float.BinFloat::one()
  let three = @bin_float.BinFloat::from_int(3)
  let third = one / three
  inspect(third, content="6004799503160661p-54")
  inspect(third.to_shortest_string(), content="0.3333333333333333")
  inspect(one / @bin_float.BinFloat::zero(), content="inf")
  inspect(@bin_float.BinFloat::from_int(7).remainder(@bin_float.BinFloat::from_int(2)), content="-1p0")
  inspect(@bin_float.BinFloat::from_int(3).pow_int(-2).unwrap().to_shortest_string(), content="0.1111111111111111")
}

上下文、舍入与标志

`BinaryRoundingMode`

上下文的舍入方向属性。

pub(all) enum BinaryRoundingMode {
  RoundTiesToEven
  RoundTiesToAway
  RoundTowardZero
  RoundTowardPositive
  RoundTowardNegative
  RoundAwayFromZero
} derive(Eq, @debug.Debug)
pub fn BinaryRoundingMode::equal(Self, Self) -> Bool
pub fn BinaryRoundingMode::not_equal(Self, Self) -> Bool
pub fn BinaryRoundingMode::to_repr(Self) -> @debug.Repr

前五个是 IEEE 754-2019 的舍入方向（第 4.3 条）。RoundAwayFromZero 是一个额外的定向模式（将绝对值向上舍入），供 GDA 风格的 @lf_arith.RoundingMode::AwayFromZero 使用。每种模式都是一个单调映射 $\mathbb{R} \to F \cup \{\pm\infty\}$ ；设计文档给出了它们的定义。

`BinaryRoundingMode::from_arithmetic`, `BinaryRoundingMode::to_arithmetic`

与 @lf_arith.RoundingMode 相互转换。

pub fn BinaryRoundingMode::from_arithmetic(@arithmetic.RoundingMode) -> Self
pub fn BinaryRoundingMode::to_arithmetic(Self) -> @arithmetic.RoundingMode?

to_arithmetic(RoundTiesToAway) 为 None，因为 @lf_arith.RoundingMode 没有 ties-to-away 模式；其他模式一一对应。

`TininessDetection`

非零结果在何种情况下对下溢标志而言算作微小。

pub(all) enum TininessDetection {
  BeforeRounding
  AfterRounding
} derive(Eq, @debug.Debug)
pub fn TininessDetection::equal(Self, Self) -> Bool
pub fn TininessDetection::not_equal(Self, Self) -> Bool
pub fn TininessDetection::to_repr(Self) -> @debug.Repr

BeforeRounding 在精确值满足 $|x| < 2^{e_{\min}}$ 时认为结果微小。AfterRounding 在 $x$ 以无界指数范围舍入到 $p$ 位后绝对值低于 $2^{e_{\min}}$ 时认为结果微小（IEEE 754-2019 第 7.5 条）。默认为 AfterRounding。只有既微小又不精确的结果才会触发下溢。

`BinaryContext`

单次运算的精度、舍入方向、指数范围与微小性规则。

pub struct BinaryContext {
  // private fields
} derive(Eq, @debug.Debug)
pub fn BinaryContext::equal(Self, Self) -> Bool
pub fn BinaryContext::not_equal(Self, Self) -> Bool
pub fn BinaryContext::to_repr(Self) -> @debug.Repr

上下文是不可变的值；不存在全局或线程状态。与 IEEE 754 一样， $e_{\min}$ 和 $e_{\max}$ 是最高位的指数：正规数满足 $2^{e_{\min}} \le |x| < 2^{e_{\max}+1}$ ，最大有限值为 $(2 - 2^{1-p})\,2^{e_{\max}}$ ，最小正次正规数为 $2^{e_{\min}-p+1}$ 。缺省的边界即实现边界。

`BinaryContext::new`, `BinaryContext::try_new`, `BinaryContext::unbounded`

构建上下文。

pub fn BinaryContext::new(Int, rounding? : BinaryRoundingMode, e_min? : Int, e_max? : Int, tininess? : TininessDetection) -> Self
pub fn BinaryContext::try_new(Int, rounding? : BinaryRoundingMode, e_min? : Int, e_max? : Int, tininess? : TininessDetection) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BinaryContext::unbounded(Int, rounding? : BinaryRoundingMode) -> Self

第一个参数是精度 $p$ 。默认值：RoundTiesToEven、无显式指数边界、AfterRounding。当 $p \le 0$ 、 $p >$ binary_precision_max，或同时给出两个边界且 $e_{\min} > e_{\max}$ 时，new 中止；在这些情况下 try_new 返回 domain_error。unbounded(p) 没有显式边界，因此只适用实现范围。

`BinaryContext::binary16`, `BinaryContext::binary32`, `BinaryContext::binary64`, `BinaryContext::binary128`

IEEE 754 交换格式的上下文。

pub fn BinaryContext::binary16(rounding? : BinaryRoundingMode, tininess? : TininessDetection) -> Self
pub fn BinaryContext::binary32(rounding? : BinaryRoundingMode, tininess? : TininessDetection) -> Self
pub fn BinaryContext::binary64(rounding? : BinaryRoundingMode, tininess? : TininessDetection) -> Self
pub fn BinaryContext::binary128(rounding? : BinaryRoundingMode, tininess? : TininessDetection) -> Self

每个都是相应格式的 BinaryInterchangeFormat::context：

上下文	$p$	$e_{\min}$	$e_{\max}$
`binary16`	11	−14	15
`binary32`	24	−126	127
`binary64`	53	−1022	1023
`binary128`	113	−16382	16383

`BinaryContext::from_arithmetic_context`

转换一个 @lf_arith.ArithmeticContext。

pub fn BinaryContext::from_arithmetic_context(@arithmetic.ArithmeticContext) -> Self

精度、舍入方式和可选边界会被复制；clamp 字段在二进制下没有意义，因此被忽略；微小性规则为 AfterRounding。超出 $[1, 2^{28}]$ 的精度会中止，与 new 相同。

`BinaryContext::precision`, `BinaryContext::rounding`, `BinaryContext::e_min`, `BinaryContext::e_max`, `BinaryContext::tininess`

读取上下文的字段。

pub fn BinaryContext::precision(Self) -> Int
pub fn BinaryContext::rounding(Self) -> BinaryRoundingMode
pub fn BinaryContext::e_min(Self) -> Int?
pub fn BinaryContext::e_max(Self) -> Int?
pub fn BinaryContext::tininess(Self) -> TininessDetection

e_min 和 e_max 按给定值返回边界（无界一侧为 None），不与实现范围取交。

`BinaryFlags`

由一个或多个运算触发的五个 IEEE 754 异常标志。

pub struct BinaryFlags {
  // private fields
} derive(Eq, @debug.Debug)
pub fn BinaryFlags::new() -> Self
pub fn BinaryFlags::inexact(Self) -> Bool
pub fn BinaryFlags::underflow(Self) -> Bool
pub fn BinaryFlags::overflow(Self) -> Bool
pub fn BinaryFlags::division_by_zero(Self) -> Bool
pub fn BinaryFlags::invalid_operation(Self) -> Bool
pub fn BinaryFlags::equal(Self, Self) -> Bool
pub fn BinaryFlags::not_equal(Self, Self) -> Bool
pub fn BinaryFlags::to_repr(Self) -> @debug.Repr

new() 的所有标志均为清除状态。上下文式运算只返回它自身触发的标志；在你组合标志之前，没有任何标志是粘滞的。各标志含义如下：inexact，返回值与精确结果不同；underflow，结果微小且不精确；overflow，舍入后的结果超过最大有限值（总是与 inexact 一同出现）；division_by_zero，有限操作数得到精确的无穷结果（如 $1/0$ 或 $\log 0$ ）；invalid_operation，不存在有意义的实数结果并返回了静默 NaN，或者某个操作数是信号 NaN。

`BinaryFlags::combine`

返回两个标志集合的并。

pub fn BinaryFlags::combine(Self, Self) -> Self

combine 是按位或：满足结合律、交换律和幂等律，并以 new() 为单位元，因此一次计算的标志可以按任意顺序累积。

`BinaryFlags::to_testfloat_bits`

以 Berkeley TestFloat 的位布局编码标志。

pub fn BinaryFlags::to_testfloat_bits(Self) -> Int

inexact 为 0x01，underflow 为 0x02，overflow 为 0x04，division by zero 为 0x08，invalid 为 0x10。

上下文式算术

本组中的每个方法都返回 (value, flags)，在上下文下对精确结果只舍入一次，并施加上下文的指数范围：上溢时根据舍入方向返回 $\pm\infty$ 或最大有限绝对值，微小结果在量子为 $2^{e_{\min}-p+1}$ 的次正规网格上舍入。返回值带有上下文精度。NaN 操作数产生静默化后的第一个 NaN 操作数（保留其符号和 payload），并且仅当某个操作数为信号 NaN 时才触发 invalid_operation。

`BinFloat::round_ctx`

将值舍入到上下文中。

pub fn BinFloat::round_ctx(Self, BinaryContext) -> (Self, BinaryFlags)

这是 IEEE 中将较宽的值转换为较窄格式的操作。有限值按完整的上溢、次正规和微小性规则舍入；无穷保持不变；信号 NaN 被静默化并触发 invalid_operation。

`BinFloat::add_ctx`, `BinFloat::sub_ctx`, `BinFloat::mul_ctx`, `BinFloat::div_ctx`

上下文下的四则运算。

pub fn BinFloat::add_ctx(Self, Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::sub_ctx(Self, Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::mul_ctx(Self, Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::div_ctx(Self, Self, BinaryContext) -> (Self, BinaryFlags)

\texttt{x.op\_ctx(y, ctx)} = \bigl(\circ(x \mathbin{\mathrm{op}} y),\ \text{flags}\bigr).

无效运算（sub 取负后符号相同的 $\infty - \infty$ 、 $0 \cdot \infty$ 、 $0/0$ 、 $\infty/\infty$ ）给出静默 NaN 并触发 invalid_operation；非零有限数除以零给出带符号无穷并触发 division_by_zero。符号相反的操作数的精确零和为 $+0$ ，但在 RoundTowardNegative 下为 $-0$ ； $(-0) + (-0) = -0$ （IEEE 754-2019 第 6.3 条）。

`BinFloat::sqrt_ctx`

上下文下的平方根。

pub fn BinFloat::sqrt_ctx(Self, BinaryContext) -> (Self, BinaryFlags)

$\sqrt{\pm 0} = \pm 0$ ， $\sqrt{+\infty} = +\infty$ ，负的非零参数给出静默 NaN 并触发 invalid_operation。

`BinFloat::fma_ctx`

上下文下的融合乘加 $\circ(x \cdot y + z)$ 。

pub fn BinFloat::fma_ctx(Self, Self, Self, BinaryContext) -> (Self, BinaryFlags)

乘积被精确构成，和只舍入一次（IEEE 754-2019 第 5.4.1 条）。NaN 操作数按 self、乘数、加数的顺序传播第一个 NaN。以下情况触发 invalid_operation：信号 NaN； $\infty \cdot 0$ （与 SoftFloat 一样，加数为静默 NaN 时也是如此）； $\pm\infty \cdot y + (\mp\infty)$ 。

`BinFloat::remainder_ctx`

上下文下的 IEEE 754 余数。

pub fn BinFloat::remainder_ctx(Self, Self, BinaryContext) -> (Self, BinaryFlags)

结果为 $r = x - n y$ ，其中 $n = \operatorname{round\_ties\_even}(x/y)$ ，因此 $|r| \le |y|/2$ 。零结果带有 $x$ 的符号。 $x = \pm\infty$ 或 $y = 0$ 给出静默 NaN 并触发 invalid_operation； $y = \pm\infty$ 或 $x = 0$ 时返回舍入到上下文中的 $x$ 。随后对精确的 $r$ 进行舍入；对于可在上下文中表示的操作数，这次舍入是精确的，不触发任何标志。商从不被显式构成：操作数按模 $2y$ 约简，因此巨大的指数差距只需 $O(\log)$ 次乘法。

`BinFloat::pow_int_ctx`, `BinFloat::pown_ctx`

上下文下的整数次幂 $\circ(x^n)$ 。

pub fn BinFloat::pow_int_ctx(Self, Int, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::pown_ctx(Self, Int, BinaryContext) -> (Self, BinaryFlags)

这两个名字是同一个函数，即 IEEE 754 的 pown。对任意 $x$ （包括 NaN）， $x^0 = 1$ ； $(\pm 0)^{n<0} = \pm\infty$ （奇数 $n$ 时保留符号）并触发 division_by_zero； $(\pm\infty)^n$ 是无穷或零，符号按奇次幂规则确定。小次幂精确计算；否则用 Ziv 循环对包络进行舍入，并有精确回退，因此结果总是正确舍入的。

///|
test "contextual operations return value and flags" {
  let ctx = @bin_float.BinaryContext::binary32()
  let one = @bin_float.BinFloat::one()
  let (third, flags) = one.div_ctx(@bin_float.BinFloat::from_int(3), ctx)
  inspect(third.to_shortest_string_ctx(ctx), content="0.33333334")
  inspect(flags.to_testfloat_bits(), content="1")
  let (inf, zero_flags) = one.div_ctx(@bin_float.BinFloat::zero(), ctx)
  inspect("\{inf} \{zero_flags.division_by_zero()}", content="inf true")
}

IEEE 754 运算

`BinFloat::to_integral_value_ctx`, `BinFloat::to_integral_exact_ctx`

按上下文的舍入方向舍入为整数值。

pub fn BinFloat::to_integral_value_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::to_integral_exact_ctx(Self, BinaryContext) -> (Self, BinaryFlags)

它们是 IEEE 的 roundToIntegral（按上下文方向）和 roundToIntegralExact。只使用上下文的舍入方向；结果保留操作数的精度以及零结果的符号。值发生改变时，to_integral_exact_ctx 触发 inexact；to_integral_value_ctx 从不触发它。无穷原样返回，信号 NaN 被静默化并触发 invalid_operation。

`BinFloat::floor`, `BinFloat::ceil`, `BinFloat::trunc`, `BinFloat::round`, `BinFloat::round_ties_even`

按固定方向舍入为整数值。

pub fn BinFloat::floor(Self) -> Self
pub fn BinFloat::ceil(Self) -> Self
pub fn BinFloat::trunc(Self) -> Self
pub fn BinFloat::round(Self) -> Self
pub fn BinFloat::round_ties_even(Self) -> Self

它们是 roundToIntegralTowardNegative、…TowardPositive、…TowardZero、…TiesToAway 和 …TiesToEven。round 将正好居中的情形向远离零的方向舍入：round(-2.5) = -3，而 round_ties_even(-2.5) = -2。

`BinFloat::to_int_ctx`, `BinFloat::to_int64_ctx`, `BinFloat::to_uint_ctx`, `BinFloat::to_uint64_ctx`

IEEE convertToInteger：按上下文的舍入方向转换为机器整数。

pub fn BinFloat::to_int_ctx(Self, BinaryContext, exact? : Bool) -> (Int?, BinaryFlags)
pub fn BinFloat::to_int64_ctx(Self, BinaryContext, exact? : Bool) -> (Int64?, BinaryFlags)
pub fn BinFloat::to_uint_ctx(Self, BinaryContext, exact? : Bool) -> (UInt?, BinaryFlags)
pub fn BinFloat::to_uint64_ctx(Self, BinaryContext, exact? : Bool) -> (UInt64?, BinaryFlags)

值先被舍入为整数。若该整数在目标类型范围内，结果为 Some；使用 exact=true（convertToIntegerExact）时，若舍入改变了值则触发 inexact。NaN、无穷或超出目标范围的整数给出 None 并触发 invalid_operation，而 C 实现在此会返回未指定的哨兵值。对无符号目标，舍入为零的负值转换为 0。

`BinFloat::next_up_ctx`, `BinFloat::next_down_ctx`

上下文格式中的 IEEE nextUp 和 nextDown。

pub fn BinFloat::next_up_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::next_down_ctx(Self, BinaryContext) -> (Self, BinaryFlags)

next_up_ctx(x) 是上下文格式（精度和指数范围，包括次正规数）中大于 $x$ 的最小值；next_down_ctx 为 $-\texttt{next\_up}(-x)$ 。上下文的舍入方向被忽略。这些运算是静默的： $\operatorname{nextUp}(\pm 0)$ 是最小正次正规数， $\operatorname{nextUp}(-\infty)$ 是最负的有限值， $\operatorname{nextUp}(\Omega) = +\infty$ 且不触发上溢标志，只有信号 NaN 会触发 invalid_operation。位数多于上下文精度的操作数也被接受。

`BinFloat::scaleb_ctx`, `BinFloat::logb_ctx`

IEEE scaleB 与 logB。

pub fn BinFloat::scaleb_ctx(Self, Int, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::logb_ctx(Self, BinaryContext) -> (Self, BinaryFlags)

x.scaleb_ctx(n, ctx) 为 $\circ(x \cdot 2^n)$ ，按常规方式处理上溢和下溢；除非结果离开正规范围，否则它是精确的。x.logb_ctx(ctx) 是作为精确整数值的 $\lfloor \log_2 |x| \rfloor$ （对次正规的 $x$ 同样如此）： $\operatorname{logB}(0) = -\infty$ 并触发 division_by_zero， $\operatorname{logB}(\pm\infty) = +\infty$ ，NaN 会传播。

///|
test "IEEE integral, integer and neighbour operations" {
  let ctx = @bin_float.BinaryContext::binary64()
  let x = @bin_float.BinFloat::from_string("-2.5").unwrap()
  inspect(
    "\{x.floor()} \{x.ceil()} \{x.trunc()} \{x.round()} \{x.round_ties_even()}",
    content="-3p0 -1p1 -1p1 -3p0 -1p1",
  )
  let (n, flags) = x.to_int_ctx(ctx, exact=true)
  inspect("\{n.unwrap()} \{flags.inexact()}", content="-2 true")
  let (up, _) = @bin_float.BinFloat::one().next_up_ctx(ctx)
  inspect(up.to_hex(), content="0x10000000000001p-52")
  let (tiny, _) = @bin_float.BinFloat::zero().next_up_ctx(ctx)
  inspect(tiny.to_shortest_string_ctx(ctx), content="5e-324")
}

比较与排序

`BinFloat::compare`

在所有值上都为全的数值三路比较。

pub fn BinFloat::compare(Self, Self) -> Int
pub impl Compare for BinFloat
pub fn BinFloat::op_lt(Self, Self) -> Bool
pub fn BinFloat::op_le(Self, Self) -> Bool
pub fn BinFloat::op_gt(Self, Self) -> Bool
pub fn BinFloat::op_ge(Self, Self) -> Bool

compare 按数值返回 $-1$ 、 $0$ 或 $1$ ，其中 $-0 = +0$ ，并忽略精度。NaN 没有数值顺序，因此 compare 将所有 NaN 视为彼此相等，并大于所有非 NaN 值；它从不中止。结果是一个全预序，这正是 Compare（以及排序）所需要的，但它不是 IEEE 比较：在它之下 nan > 1 成立。运算符 <、<=、>、>= 以及被提升的 op_* 方法使用 compare。若需要 IEEE 语义，请使用 compare_checked、下文的静默与信号谓词，或 total_order。设计文档解释了这一选择。

`BinFloat::compare_checked`

拒绝 NaN 的数值比较。

pub fn BinFloat::compare_checked(Self, Self) -> Result[Int, @arithmetic.ArithmeticError]
pub impl @arithmetic.CompareChecked for BinFloat

当两个操作数都不是 NaN 时返回与 compare 相同的值，否则返回 unordered_comparison 错误。

`BinFloat::compare_quiet`, `BinFloat::compare_signaling`

带标志的四值关系形式的 IEEE 比较。

pub fn BinFloat::compare_quiet(Self, Self) -> (@def.PartialOrder, BinaryFlags)
pub fn BinFloat::compare_signaling(Self, Self) -> (@def.PartialOrder, BinaryFlags)

关系为 Less、Equal、Greater 或 Unordered（某个操作数为 NaN），其中 $-0 = +0$ 。静默形式只对信号 NaN 触发 invalid_operation；信号形式对每次无序比较都触发它（IEEE 754-2019 第 5.11 条）。

`BinFloat::equal_quiet`, `BinFloat::less_quiet`, `BinFloat::less_equal_quiet`, `BinFloat::unordered_quiet`, `BinFloat::equal_signaling`, `BinFloat::less_signaling`, `BinFloat::less_equal_signaling`

IEEE 比较谓词。

pub fn BinFloat::equal_quiet(Self, Self) -> (Bool, BinaryFlags)
pub fn BinFloat::less_quiet(Self, Self) -> (Bool, BinaryFlags)
pub fn BinFloat::less_equal_quiet(Self, Self) -> (Bool, BinaryFlags)
pub fn BinFloat::unordered_quiet(Self, Self) -> (Bool, BinaryFlags)
pub fn BinFloat::equal_signaling(Self, Self) -> (Bool, BinaryFlags)
pub fn BinFloat::less_signaling(Self, Self) -> (Bool, BinaryFlags)
pub fn BinFloat::less_equal_signaling(Self, Self) -> (Bool, BinaryFlags)

即 compareQuietEqual、compareQuietLess、compareQuietLessEqual、compareQuietUnordered 以及信号版本的 Equal、Less、LessEqual。每个谓词都由 compare_quiet 或 compare_signaling 派生并返回其标志；除 unordered_quiet 外，每个谓词在无序对上都为假。

`BinFloat::total_order`, `BinFloat::total_order_mag`, `BinFloat::total_order_compare`

IEEE 754 的 totalOrder 关系。

pub fn BinFloat::total_order(Self, Self) -> Bool
pub fn BinFloat::total_order_mag(Self, Self) -> Bool
pub fn BinFloat::total_order_compare(Self, Self) -> Int

total_order_compare 将所有值排序为

-\mathrm{qNaN} < -\mathrm{sNaN} < -\infty < \text{negative finite} < -0 < +0 < \text{positive finite} < +\infty < +\mathrm{sNaN} < +\mathrm{qNaN},

同一符号和种类的 NaN 按 payload 排序（负侧顺序相反）。x.total_order(y) 即 total_order_compare(x, y) <= 0，total_order_mag 比较绝对值。数值相等但精度不同的值比较为相等。这些运算是静默的。

`BinFloat::min`, `BinFloat::max`

两个值中较小或较大的一个，忽略 NaN 操作数。

pub fn BinFloat::min(Self, Self) -> Self
pub fn BinFloat::max(Self, Self) -> Self

当恰有一个操作数为 NaN 时，返回另一个（即 IEEE 754-2008 中针对静默 NaN 的 minNum/maxNum 约定）。当两个操作数在 compare 下相等时（例如 $-0$ 和 $+0$ ），返回接收者。不产生标志。

`BinFloat::clamp`, `BinFloat::clamp_checked`

将值限制在 [min, max] 内。

pub fn BinFloat::clamp(Self, min~ : Self, max~ : Self) -> Self
pub fn BinFloat::clamp_checked(Self, min~ : Self, max~ : Self) -> Result[Self, @arithmetic.ArithmeticError]

NaN 接收者原样返回。当某个边界为 NaN 或 min > max 时，clamp 中止；在这些情况下 clamp_checked 返回 domain_error。

`BinFloat::equal`, `BinFloat::not_equal`

结构相等，即派生的 Eq。

pub fn BinFloat::equal(Self, Self) -> Bool
pub fn BinFloat::not_equal(Self, Self) -> Bool

参见 BinFloat：它比较的是表示，而不是数值。

///|
test "three different orders on BinFloat" {
  let nan = @bin_float.BinFloat::nan()
  let zero = @bin_float.BinFloat::zero()
  let neg_zero = @bin_float.BinFloat::negative_zero()
  inspect(nan.compare(zero), content="1")
  inspect(nan.compare_checked(zero) is Err(_), content="true")
  let (unordered, flags) = zero.unordered_quiet(nan)
  inspect("\{unordered} \{flags.invalid_operation()}", content="true false")
  inspect(neg_zero.compare(zero), content="0")
  inspect(neg_zero.total_order_compare(zero), content="-1")
  inspect(neg_zero == zero, content="false")
  let values = [nan, @bin_float.BinFloat::inf(@def.Sign::Positive), zero, @bin_float.BinFloat::from_int(-3)]
  values.sort()
  inspect(values.map(fn(v) { v.to_string() }).join(" "), content="-3p0 0 inf nan")
}

文本与十六进制转换

`BinFloat::to_string`

以 coefficient p exponent 形式输出精确的存储值。

pub fn BinFloat::to_string(Self) -> String
pub fn BinFloat::output(Self, &Logger) -> Unit
pub impl Show for BinFloat

有限非零值输出为 [-]<c>p<e>，其中 $c$ 以十进制表示，含义为 $c \cdot 2^e$ （例如 3p-1 为 $1.5$ ）。零输出为 0 和 -0，无穷输出为 inf 和 -inf，所有 NaN 输出为 nan。该形式精确且无歧义，但不是十进制表示；如需十进制表示请使用 to_shortest_string。

`BinFloat::from_string`, `BinFloat::from_string_ctx`

以正确舍入解析十进制字面量（IEEE convertFromDecimalCharacter）。

pub fn BinFloat::from_string(String, precision? : Int) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BinFloat::from_string_ctx(String, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]

接受的语法为 [+-]digits[.digits][e[+-]digits]（允许前导或末尾的小数点，指数标记为 e 或 E），以及不区分大小写的单词 inf、infinity、nan、qnan 和 snan，两侧空白被忽略。其他任何内容都是 parse_error。精确的十进制值 $D \cdot 10^k$ 在上下文下只舍入一次，无论位数多少、指数多大；上溢、下溢和不精确与算术运算一样报告。from_string(s, precision=p) 使用 unbounded(p)（默认 53）并丢弃标志。

`BinFloat::to_decimal_string_ctx`

以固定的十进制有效位数格式化值（IEEE convertToDecimalCharacter）。

pub fn BinFloat::to_decimal_string_ctx(Self, Int, BinaryContext) -> (String, BinaryFlags)

输出为 [-]d.ddd…e±x，恰有 digits 位有效数字（至少 1 位），按上下文的舍入方向正确舍入；丢弃了非零数字时触发 inexact。只使用上下文的舍入方向。零输出为带符号的 0.00…e+0，无穷输出为 inf/-inf，NaN 输出为带符号的 nan/snan。该文本可用 from_string_ctx 解析回来。

`BinFloat::to_shortest_string`, `BinFloat::to_shortest_string_ctx`

格式化为能读回同一值的最短十进制数。

pub fn BinFloat::to_shortest_string(Self) -> String
pub fn BinFloat::to_shortest_string_ctx(Self, BinaryContext) -> String

to_shortest_string_ctx(x, ctx) 返回有效位数最少、且在就近舍入（偶数优先）下经 from_string_ctx(_, ctx) 映射回 $x$ 的十进制数（上下文自身的舍入方向被忽略）。当该长度下有两个候选都能读回时，选择较近的那个，其次选择末位为偶数的那个。版式遵循 ECMAScript Number#toString：十进制指数在 $[-6, 21)$ 内时使用定点记法，否则使用 d.ddde±x；与 ECMAScript 不同， $-0$ 输出为 -0。对于 BinaryContext::binary64() 中的 binary64 值，结果与宿主 Double 的格式化器一致。to_shortest_string() 使用 unbounded(precision())，因此它是 from_string(text, precision=x.precision()) 能映射回 x 的最短字符串。操作数应当可在该上下文中表示。

`BinFloat::from_hex`, `BinFloat::to_hex`

以十六进制系数读写精确值。

pub fn BinFloat::from_hex(String, Int) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BinFloat::to_hex(Self) -> String

语法为 [+-]0x<hexdigits>p<decimal exponent>，含义为整数系数乘以 $2^{\text{exponent}}$ ：0x3p-1 为 $1.5$ 。没有十六进制小数点，因此 C 风格的 0x1.8p0 是 parse_error。from_hex(s, p) 以就近舍入（偶数优先）舍入到精度 p，并且也接受带符号的 nan、inf 和 infinity。to_hex 以小写输出存储的系数，零输出为 0x0p0，nan/inf 带符号输出。

///|
test "decimal and hexadecimal text" {
  let tenth = @bin_float.BinFloat::from_string("0.1").unwrap()
  inspect(tenth, content="3602879701896397p-55")
  inspect(tenth.to_hex(), content="0xccccccccccccdp-55")
  inspect(tenth.to_shortest_string(), content="0.1")
  let ctx = @bin_float.BinaryContext::binary64()
  let (digits, flags) = tenth.to_decimal_string_ctx(25, ctx)
  inspect("\{digits} \{flags.inexact()}", content="1.000000000000000055511151e-1 true")
  let (single, _) = @bin_float.BinFloat::from_string_ctx("0.1", @bin_float.BinaryContext::binary32()).unwrap()
  inspect(single, content="13421773p-27")
  inspect(@bin_float.BinFloat::from_hex("0x3p-1", 53).unwrap(), content="3p-1")
}

交换编码

`BinaryInterchangeFormat`

四种 IEEE 754 二进制交换格式。

pub(all) enum BinaryInterchangeFormat {
  Binary16
  Binary32
  Binary64
  Binary128
} derive(Eq, @debug.Debug)
pub fn BinaryInterchangeFormat::equal(Self, Self) -> Bool
pub fn BinaryInterchangeFormat::not_equal(Self, Self) -> Bool
pub fn BinaryInterchangeFormat::to_repr(Self) -> @debug.Repr

`BinaryInterchangeFormat::precision`, `BinaryInterchangeFormat::e_min`, `BinaryInterchangeFormat::e_max`, `BinaryInterchangeFormat::bias`, `BinaryInterchangeFormat::exponent_bits`, `BinaryInterchangeFormat::fraction_bits`, `BinaryInterchangeFormat::total_bits`

格式的参数。

pub fn BinaryInterchangeFormat::precision(Self) -> Int
pub fn BinaryInterchangeFormat::e_min(Self) -> Int
pub fn BinaryInterchangeFormat::e_max(Self) -> Int
pub fn BinaryInterchangeFormat::bias(Self) -> Int
pub fn BinaryInterchangeFormat::exponent_bits(Self) -> Int
pub fn BinaryInterchangeFormat::fraction_bits(Self) -> Int
pub fn BinaryInterchangeFormat::total_bits(Self) -> Int

格式	`total_bits` $k$	`exponent_bits` $w$	`fraction_bits` $p-1$	`precision` $p$	`bias` $= e_{\max}$	`e_min` $= 1 - e_{\max}$
`Binary16`	16	5	10	11	15	−14
`Binary32`	32	8	23	24	127	−126
`Binary64`	64	11	52	53	1023	−1022
`Binary128`	128	15	112	113	16383	−16382

`BinaryInterchangeFormat::context`

返回该格式的 BinaryContext。

pub fn BinaryInterchangeFormat::context(Self, rounding? : BinaryRoundingMode, tininess? : TininessDetection) -> BinaryContext

`BinaryInterchange`

一个编码值：格式及其位模式。

pub struct BinaryInterchange {
  // private fields
} derive(Eq)
pub fn BinaryInterchange::equal(Self, Self) -> Bool
pub fn BinaryInterchange::not_equal(Self, Self) -> Bool
pub fn BinaryInterchange::format(Self) -> BinaryInterchangeFormat
pub fn BinaryInterchange::bits(Self) -> BinCoeff

相等性比较格式和位，因此 payload 不同的两个 NaN 编码不相等， $\pm 0$ 也不相等。

`BinaryInterchange::from_bits`, `BinaryInterchange::from_hex`, `BinaryInterchange::to_hex`

构建或输出编码。

pub fn BinaryInterchange::from_bits(BinCoeff, BinaryInterchangeFormat) -> Self
pub fn BinaryInterchange::from_hex(String, BinaryInterchangeFormat) -> Self?
pub fn BinaryInterchange::to_hex(Self) -> String

from_bits 保留低 total_bits 位。from_hex 需要恰好 total_bits / 4 个十六进制数字，可带 0x 或 # 前缀，否则返回 None。to_hex 输出补齐到完整宽度的大写数字。

`BinaryInterchange::to_bin_float`

精确解码一个编码。

pub fn BinaryInterchange::to_bin_float(Self) -> BinFloat

结果具有该格式的精度。正规数、次正规数、带符号零和无穷都被精确解码；NaN 保留其符号和 payload（不含静默位的尾数），信号 NaN 仍为信号 NaN。整个过程不涉及宿主的 Float 或 Double。

`BinaryInterchange::from_bin_float`, `BinFloat::to_interchange`

将值舍入到某格式并编码。

pub fn BinaryInterchange::from_bin_float(BinFloat, BinaryInterchangeFormat, rounding? : BinaryRoundingMode, tininess? : TininessDetection) -> (Self, BinaryFlags)
pub fn BinFloat::to_interchange(Self, BinaryInterchangeFormat, rounding? : BinaryRoundingMode, tininess? : TininessDetection) -> (BinaryInterchange, BinaryFlags)

二者是同一个操作：先以该格式的上下文执行 round_ctx，再编码。信号 NaN 被编码为静默 NaN 并触发 invalid_operation，payload 被截断到 payload 字段。

///|
test "encode and decode interchange bits" {
  let b32 = @bin_float.BinaryInterchangeFormat::Binary32
  let tenth = @bin_float.BinFloat::from_string("0.1", precision=200).unwrap()
  let (nearest, flags) = tenth.to_interchange(b32)
  inspect("\{nearest.to_hex()} \{flags.inexact()}", content="3DCCCCCD true")
  let (chopped, _) = tenth.to_interchange(
    b32,
    rounding=@bin_float.BinaryRoundingMode::RoundTowardZero,
  )
  inspect(chopped.to_hex(), content="3DCCCCCC")
  let snan = @bin_float.BinaryInterchange::from_hex("7F800001", b32)
    .unwrap()
    .to_bin_float()
  let (quieted, nan_flags) = snan.to_interchange(b32)
  inspect("\{quieted.to_hex()} \{nan_flags.invalid_operation()}", content="7FC00001 true")
}

初等函数

每个初等函数都有三种形式：

f(x) 以 x 的精度（两个操作数时取较大精度）在实现指数范围内就近舍入（偶数优先）；
f_ctx(x, ctx) 在 ctx 下舍入并返回 (value, flags)；
try_f_ctx(x, ctx) 在 Ok 中返回同样的值对，或返回 @lf_arith.ArithmeticError。

三者运行同一个认证算法：在 $p + 64$ 位的工作精度下用定向舍入得到精确值的包络，并最多细化 12 次（每步增加 $\max(32, w/2)$ 位），直到包络两端舍入为相同的值并带有相同的标志。因此返回值总是正确舍入的结果 $\circ(f(x))$ ，且 inexact 是准确的。当预算耗尽时，try_f_ctx 返回 certification_failure 错误，其 CertificationFailureDetail 指明运算、阶段（RangeReduction 或 TargetRounding）、原因以及最后的工作精度。超出实定义域的参数使 try_f_ctx 给出 domain_error。非 try 形式将这两类错误都转为静默 NaN 并触发 invalid_operation。NaN 操作数静默传播，极点返回带符号无穷并触发 division_by_zero（例如 $\ln 0 = -\infty$ ， $\operatorname{atanh}(1) = +\infty$ ）。包络无法分离的可精确表示结果会被预先检测，例如 $\log_2 2^k = k$ 、整数 $n$ 的 $2^n$ 、 $\sin(\pm 0) = \pm 0$ 以及 $\operatorname{sinpi}(1/2) = 1$ 。

`BinFloat::exp`, `BinFloat::expm1`, `BinFloat::exp2`, `BinFloat::exp10`

指数函数 $e^x$ 、 $e^x - 1$ 、 $2^x$ 和 $10^x$ 。

pub fn BinFloat::exp(Self) -> Self
pub fn BinFloat::exp_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::try_exp_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::expm1(Self) -> Self
pub fn BinFloat::expm1_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::try_expm1_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::exp2(Self) -> Self
pub fn BinFloat::exp2_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::try_exp2_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::exp10(Self) -> Self
pub fn BinFloat::exp10_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::try_exp10_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]

在整个 $\mathbb{R}$ 上有定义； $f(-\infty) = 0$ （对 expm1 为 $-1$ ）， $f(+\infty) = +\infty$ 。确定超出指数范围的结果会在主循环之前由认证的 $\log_2$ 界判定，因此巨大的参数会带着正确的标志上溢或下溢，而不会失败。

`BinFloat::ln`, `BinFloat::log1p`, `BinFloat::log2`, `BinFloat::log10`

对数函数 $\ln x$ 、 $\ln(1+x)$ 、 $\log_2 x$ 和 $\log_{10} x$ 。

pub fn BinFloat::ln(Self) -> Self
pub fn BinFloat::ln_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::try_ln_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::log1p(Self) -> Self
pub fn BinFloat::log1p_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::try_log1p_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::log2(Self) -> Self
pub fn BinFloat::log2_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::try_log2_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::log10(Self) -> Self
pub fn BinFloat::log10_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::try_log10_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]

定义域为 $x > 0$ （对 log1p 为 $x > -1$ ）。在边界处结果为 $-\infty$ 并触发 division_by_zero；低于边界的有限参数为 domain_error， $-\infty$ 给出静默 NaN 并触发 invalid_operation。

`BinFloat::exp_ln`

融合复合 $\ln(e^x)$ ，其值等于 $x$ 。

pub fn BinFloat::exp_ln(Self) -> Self
pub fn BinFloat::exp_ln_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::try_exp_ln_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]

结果是 $x$ 舍入到上下文中一次的值，没有两次中间舍入。当前实现接受满足 $|x| \le 1/8$ 的有限参数以及无穷；其他任何有限参数都会在范围约简阶段得到 certification_failure。

`BinFloat::pow`, `BinFloat::rootn`, `BinFloat::hypot`

实数幂 $x^y$ 、 $n$ 次方根 $x^{1/n}$ 以及 $\sqrt{x^2+y^2}$ 。

pub fn BinFloat::pow(Self, Self) -> Self
pub fn BinFloat::pow_ctx(Self, Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::try_pow_ctx(Self, Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::rootn(Self, Int) -> Self
pub fn BinFloat::rootn_ctx(Self, Int, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::try_rootn_ctx(Self, Int, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::hypot(Self, Self) -> Self
pub fn BinFloat::hypot_ctx(Self, Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::try_hypot_ctx(Self, Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]

pow 的特殊情形遵循 IEEE pow：对任意 $x$ 和 $y$ （包括 NaN）， $x^{\pm 0} = 1$ 且 $1^y = 1$ ；满足 $|y| < 2^{31}$ 的整数指数由 pown 处理， $y = 1/2^k$ 由 rootn 处理。否则，负的有限底数为 domain_error， $0^{y<0} = +\infty$ 并触发 division_by_zero，其值由 $y \ln x$ 的包络认证得出。rootn(x, n) 是实 $n$ 次方根：奇数 $n$ 接受负的 $x$ ，偶数 $n$ 且 $x < 0$ 为 domain_error， $n = 0$ 为 domain_error；负的 $n$ 给出 $x^{-1/n}$ ，其中 $\operatorname{rootn}(\pm 0, n<0) = \pm\infty$ 并触发 division_by_zero。hypot 精确地对操作数求平方，再取一次正确舍入的平方根；即使 $y$ 为 NaN， $\operatorname{hypot}(\pm\infty, y) = +\infty$ 仍成立。

`BinFloat::sin`, `BinFloat::cos`, `BinFloat::tan`

以弧度为参数的三角函数。

pub fn BinFloat::sin(Self) -> Self
pub fn BinFloat::sin_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::try_sin_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::cos(Self) -> Self
pub fn BinFloat::cos_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::try_cos_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::tan(Self) -> Self
pub fn BinFloat::tan_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::try_tan_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]

参数用在 $p + \max(0, \lfloor\log_2|x|\rfloor + 1) + 96$ 位下计算的 $\pi/2$ 包络进行约简，因此对每个有限输入，约简在包络意义下都是精确的。无穷参数为 domain_error。需要多于 $10^6$ 工作位的参数（大约 $|x| > 2^{999{,}000}$ ）返回原因为 ResourceLimit 的 certification_failure。

`BinFloat::sinpi`, `BinFloat::cospi`, `BinFloat::tanpi`

$\sin(\pi x)$ 、 $\cos(\pi x)$ 和 $\tan(\pi x)$ 。

pub fn BinFloat::sinpi(Self) -> Self
pub fn BinFloat::sinpi_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::try_sinpi_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::cospi(Self) -> Self
pub fn BinFloat::cospi_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::try_cospi_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::tanpi(Self) -> Self
pub fn BinFloat::tanpi_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::try_tanpi_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]

周期在二进制表示上被精确约简，因此巨大参数不会带来额外开销。整数和半整数给出精确结果：对整数 $n$ ， $\operatorname{sinpi}(n) = \pm 0$ （符号与 $n$ 相同）， $\operatorname{cospi}(n) = \pm 1$ ；在 $1/2$ 的奇数倍处，cospi 为 $+0$ ，tanpi 为带符号无穷并触发 division_by_zero。无穷参数为 domain_error。

`BinFloat::asin`, `BinFloat::acos`, `BinFloat::atan`, `BinFloat::atan2`

反三角函数。

pub fn BinFloat::asin(Self) -> Self
pub fn BinFloat::asin_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::try_asin_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::acos(Self) -> Self
pub fn BinFloat::acos_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::try_acos_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::atan(Self) -> Self
pub fn BinFloat::atan_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::try_atan_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::atan2(Self, Self) -> Self
pub fn BinFloat::atan2_ctx(Self, Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::try_atan2_ctx(Self, Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]

asin 和 acos 定义在 $[-1, 1]$ 上；在其之外 asin 为 domain_error。 $\operatorname{atan}(\pm\infty) = \pm\pi/2$ ，正确舍入。y.atan2(x) 是点 $(x, y)$ 在 $[-\pi, \pi]$ 中的辐角。无穷操作数遵循 IEEE 754（例如 $\operatorname{atan2}(+\infty, -\infty) = 3\pi/4$ ），且 $\operatorname{atan2}(\pm 0, x > 0) = \pm 0$ 。

`BinFloat::sinh`, `BinFloat::cosh`, `BinFloat::tanh`, `BinFloat::asinh`, `BinFloat::acosh`, `BinFloat::atanh`

双曲函数及其反函数。

pub fn BinFloat::sinh(Self) -> Self
pub fn BinFloat::sinh_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::try_sinh_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::cosh(Self) -> Self
pub fn BinFloat::cosh_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::try_cosh_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::tanh(Self) -> Self
pub fn BinFloat::tanh_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::try_tanh_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::asinh(Self) -> Self
pub fn BinFloat::asinh_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::try_asinh_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::acosh(Self) -> Self
pub fn BinFloat::acosh_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::try_acosh_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::atanh(Self) -> Self
pub fn BinFloat::atanh_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::try_atanh_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]

acosh 需要 $x \ge 1$ ，atanh 需要 $|x| \le 1$ ；超出这些集合时结果为 domain_error。 $\operatorname{atanh}(\pm 1) = \pm\infty$ 并触发 division_by_zero， $\operatorname{tanh}(\pm\infty) = \pm 1$ 。

///|
test "elementary functions are correctly rounded" {
  let ctx = @bin_float.BinaryContext::binary64()
  let one = @bin_float.BinFloat::one()
  inspect(one.exp_ctx(ctx).0.to_shortest_string(), content="2.718281828459045")
  inspect(@bin_float.BinFloat::from_int(8).log2(), content="3p0")
  let (big, flags) = @bin_float.BinFloat::from_int(1000).exp_ctx(ctx)
  inspect("\{big} \{flags.overflow()}", content="inf true")
  match @bin_float.BinFloat::from_int(-1).try_ln_ctx(ctx) {
    Ok(_) => fail("ln(-1) has no real value")
    Err(error) => inspect(error.is_domain_error(), content="true")
  }
  let (nan, nan_flags) = @bin_float.BinFloat::from_int(-1).ln_ctx(ctx)
  inspect("\{nan} \{nan_flags.invalid_operation()}", content="nan true")
}

trait 实现

`@def.Floating`

floating 共享的浮点词汇。

pub impl @def.Floating for BinFloat

classify、sign、precision、with_precision 和 normalized 即上文的固有方法。泛型代码使用 @def.is_finite、@def.is_nan、@def.is_infinite 和 @def.is_zero。

checked trait

方法返回 Result 的 @lf_arith trait。

pub impl @arithmetic.SqrtChecked for BinFloat
pub impl @arithmetic.DivChecked for BinFloat
pub impl @arithmetic.CompareChecked for BinFloat
pub impl @arithmetic.PowNatChecked for BinFloat
pub impl @arithmetic.PowIntChecked for BinFloat
pub fn BinFloat::sqrt_checked(Self, @arithmetic.ArithmeticContext) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BinFloat::pow_nat_checked(Self, UInt, @arithmetic.ArithmeticContext) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BinFloat::pow_int_checked(Self, Int, @arithmetic.ArithmeticContext) -> Result[Self, @arithmetic.ArithmeticError]

每个方法都用 BinaryContext::from_arithmetic_context 转换 ArithmeticContext，运行上下文式运算并丢弃标志。sqrt_checked 对负的非零参数为 domain_error（与 sqrt 一样，这包括符号位置位的 NaN）；DivChecked::div_checked 对有限的零除数为 division_by_zero 错误；pow_int_checked 对零底数配负指数为 division_by_zero 错误；pow_nat_checked 从不失败。trait 的 div_checked(x, y, ctx) 接受上下文；固有方法 BinFloat::div_checked 则不接受。

contextual trait

返回带诊断信息的 ArithmeticOutcome 的 @lf_arith trait。

pub impl @arithmetic.AddContextual for BinFloat
pub impl @arithmetic.SubContextual for BinFloat
pub impl @arithmetic.MulContextual for BinFloat
pub impl @arithmetic.DivContextual for BinFloat
pub impl @arithmetic.AbsContextual for BinFloat
pub impl @arithmetic.SqrtContextual for BinFloat
pub impl @arithmetic.ExpContextual for BinFloat
pub fn BinFloat::add_contextual(Self, Self, @arithmetic.ArithmeticContext) -> Result[@arithmetic.ArithmeticOutcome[Self], @arithmetic.ArithmeticError]
pub fn BinFloat::sub_contextual(Self, Self, @arithmetic.ArithmeticContext) -> Result[@arithmetic.ArithmeticOutcome[Self], @arithmetic.ArithmeticError]
pub fn BinFloat::mul_contextual(Self, Self, @arithmetic.ArithmeticContext) -> Result[@arithmetic.ArithmeticOutcome[Self], @arithmetic.ArithmeticError]
pub fn BinFloat::div_contextual(Self, Self, @arithmetic.ArithmeticContext) -> Result[@arithmetic.ArithmeticOutcome[Self], @arithmetic.ArithmeticError]
pub fn BinFloat::abs_contextual(Self, @arithmetic.ArithmeticContext) -> Result[@arithmetic.ArithmeticOutcome[Self], @arithmetic.ArithmeticError]
pub fn BinFloat::sqrt_contextual(Self, @arithmetic.ArithmeticContext) -> Result[@arithmetic.ArithmeticOutcome[Self], @arithmetic.ArithmeticError]
pub fn BinFloat::exp_contextual(Self, @arithmetic.ArithmeticContext) -> Result[@arithmetic.ArithmeticOutcome[Self], @arithmetic.ArithmeticError]

每个方法都在转换后的上下文下运行对应的 *_ctx 方法（对 abs 为先 abs 再 round_ctx；对 exp 为 try_exp_ctx）。带有 division_by_zero 的结果变为 division_by_zero 错误，带有 invalid_operation 的结果变为 domain_error；exp 的认证失败原样返回。否则返回值以及 ArithmeticDiagnostics，其 inexact 和 rounded 为不精确标志，overflow 和 underflow 为相应的标志。

`Show`、`Debug` 与被提升的方法

pub fn BinFloat::to_repr(Self) -> @debug.Repr

Show 即 to_string 的精确 c p e 形式。Debug（to_repr，供 debug_inspect 使用）显示所有私有字段。equal、not_equal、output、op_lt、op_le、op_gt 和 op_ge 是提升到该类型上的 trait 方法，已随其 trait 在上文中说明。

完整公共接口

// Generated using `moon info`, DON'T EDIT IT
package "Luna-Flow/floating/bin_float"

import {
  "Luna-Flow/arithmetic",
  "Luna-Flow/floating/def",
  "moonbitlang/core/debug",
}

// Values
pub let binary_implementation_e_max : Int

pub let binary_implementation_e_min : Int

pub let binary_precision_max : Int

pub fn sqrt_bounds_for_precision(BinFloat, Int) -> Result[(BinFloat, BinFloat), @arithmetic.ArithmeticError]

pub fn sqrt_for_precision(BinFloat, Int) -> Result[BinFloat, @arithmetic.ArithmeticError]

// Errors

// Types and methods
pub struct BinCoeff {
  // private fields
} derive(@debug.Debug)
pub fn BinCoeff::add(Self, Self) -> Self
pub fn BinCoeff::bit_and(Self, Self) -> Self
pub fn BinCoeff::bit_length(Self) -> Int
pub fn BinCoeff::bit_or(Self, Self) -> Self
pub fn BinCoeff::bit_xor(Self, Self) -> Self
pub fn BinCoeff::compare(Self, Self) -> Int
pub fn BinCoeff::ctz(Self) -> Int
pub fn BinCoeff::div_rem_checked(Self, Self) -> Result[(Self, Self), String]
pub fn BinCoeff::equal(Self, Self) -> Bool
pub fn BinCoeff::from_bytes_be(BytesView) -> Self
pub fn BinCoeff::from_uint64(UInt64) -> Self
pub fn BinCoeff::gcd(Self, Self) -> Self
pub fn BinCoeff::is_zero(Self) -> Bool
pub fn BinCoeff::mul(Self, Self) -> Self
pub fn BinCoeff::not_equal(Self, Self) -> Bool
pub fn BinCoeff::one() -> Self
pub fn BinCoeff::op_ge(Self, Self) -> Bool
pub fn BinCoeff::op_gt(Self, Self) -> Bool
pub fn BinCoeff::op_le(Self, Self) -> Bool
pub fn BinCoeff::op_lt(Self, Self) -> Bool
pub fn BinCoeff::output(Self, &Logger) -> Unit
pub fn BinCoeff::parse(String, radix? : Int) -> Result[Self, String]
pub fn BinCoeff::pow_nat(Self, UInt) -> Self
pub fn BinCoeff::shift_left(Self, Int) -> Self
pub fn BinCoeff::shift_right(Self, Int) -> Self
pub fn BinCoeff::shl(Self, Int) -> Self
pub fn BinCoeff::shr(Self, Int) -> Self
pub fn BinCoeff::square(Self) -> Self
pub fn BinCoeff::sub_checked(Self, Self) -> Result[Self, String]
pub fn BinCoeff::test_bit(Self, Int) -> Bool
pub fn BinCoeff::to_bytes_be(Self) -> Bytes
pub fn BinCoeff::to_radix_string(Self, Int) -> String
pub fn BinCoeff::to_repr(Self) -> @debug.Repr
pub fn BinCoeff::to_string(Self) -> String
pub fn BinCoeff::to_uint64(Self) -> UInt64?
pub fn BinCoeff::zero() -> Self
pub impl Add for BinCoeff
pub impl Compare for BinCoeff
pub impl Eq for BinCoeff
pub impl Mul for BinCoeff
pub impl Shl for BinCoeff
pub impl Show for BinCoeff
pub impl Shr for BinCoeff

pub struct BinFloat {
  // private fields
} derive(Eq, @debug.Debug)
pub fn BinFloat::abs(Self) -> Self
pub fn BinFloat::abs_contextual(Self, @arithmetic.ArithmeticContext) -> Result[@arithmetic.ArithmeticOutcome[Self], @arithmetic.ArithmeticError]
pub fn BinFloat::acos(Self) -> Self
pub fn BinFloat::acos_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::acosh(Self) -> Self
pub fn BinFloat::acosh_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::add(Self, Self) -> Self
pub fn BinFloat::add_contextual(Self, Self, @arithmetic.ArithmeticContext) -> Result[@arithmetic.ArithmeticOutcome[Self], @arithmetic.ArithmeticError]
pub fn BinFloat::add_ctx(Self, Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::asin(Self) -> Self
pub fn BinFloat::asin_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::asinh(Self) -> Self
pub fn BinFloat::asinh_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::atan(Self) -> Self
pub fn BinFloat::atan2(Self, Self) -> Self
pub fn BinFloat::atan2_ctx(Self, Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::atan_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::atanh(Self) -> Self
pub fn BinFloat::atanh_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::ceil(Self) -> Self
pub fn BinFloat::clamp(Self, min~ : Self, max~ : Self) -> Self
pub fn BinFloat::clamp_checked(Self, min~ : Self, max~ : Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BinFloat::classify(Self) -> @arithmetic.FpClass
pub fn BinFloat::coefficient(Self) -> BinCoeff
pub fn BinFloat::compare(Self, Self) -> Int
pub fn BinFloat::compare_checked(Self, Self) -> Result[Int, @arithmetic.ArithmeticError]
pub fn BinFloat::compare_quiet(Self, Self) -> (@def.PartialOrder, BinaryFlags)
pub fn BinFloat::compare_signaling(Self, Self) -> (@def.PartialOrder, BinaryFlags)
pub fn BinFloat::copy_sign(Self, Self) -> Self
pub fn BinFloat::cos(Self) -> Self
pub fn BinFloat::cos_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::cosh(Self) -> Self
pub fn BinFloat::cosh_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::cospi(Self) -> Self
pub fn BinFloat::cospi_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::div(Self, Self) -> Self
pub fn BinFloat::div_checked(Self, Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BinFloat::div_contextual(Self, Self, @arithmetic.ArithmeticContext) -> Result[@arithmetic.ArithmeticOutcome[Self], @arithmetic.ArithmeticError]
pub fn BinFloat::div_ctx(Self, Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::equal(Self, Self) -> Bool
pub fn BinFloat::equal_quiet(Self, Self) -> (Bool, BinaryFlags)
pub fn BinFloat::equal_signaling(Self, Self) -> (Bool, BinaryFlags)
pub fn BinFloat::exp(Self) -> Self
pub fn BinFloat::exp10(Self) -> Self
pub fn BinFloat::exp10_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::exp2(Self) -> Self
pub fn BinFloat::exp2_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::exp_contextual(Self, @arithmetic.ArithmeticContext) -> Result[@arithmetic.ArithmeticOutcome[Self], @arithmetic.ArithmeticError]
pub fn BinFloat::exp_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::exp_ln(Self) -> Self
pub fn BinFloat::exp_ln_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::expm1(Self) -> Self
pub fn BinFloat::expm1_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::exponent2(Self) -> Int
pub fn BinFloat::floor(Self) -> Self
pub fn BinFloat::fma(Self, Self, Self) -> Self
pub fn BinFloat::fma_ctx(Self, Self, Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::from_coefficient(BinCoeff, precision? : Int, negative? : Bool) -> Self
pub fn BinFloat::from_double(Double, precision? : Int) -> Self
pub fn BinFloat::from_float(Float, precision? : Int) -> Self
pub fn BinFloat::from_hex(String, Int) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BinFloat::from_int(Int, precision? : Int) -> Self
pub fn BinFloat::from_string(String, precision? : Int) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BinFloat::from_string_ctx(String, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::hypot(Self, Self) -> Self
pub fn BinFloat::hypot_ctx(Self, Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::inf(@def.Sign, precision? : Int) -> Self
pub fn BinFloat::is_negative(Self) -> Bool
pub fn BinFloat::is_negative_zero(Self) -> Bool
pub fn BinFloat::is_quiet_nan(Self) -> Bool
pub fn BinFloat::is_signaling_nan(Self) -> Bool
pub fn BinFloat::is_zero(Self) -> Bool
pub fn BinFloat::less_equal_quiet(Self, Self) -> (Bool, BinaryFlags)
pub fn BinFloat::less_equal_signaling(Self, Self) -> (Bool, BinaryFlags)
pub fn BinFloat::less_quiet(Self, Self) -> (Bool, BinaryFlags)
pub fn BinFloat::less_signaling(Self, Self) -> (Bool, BinaryFlags)
pub fn BinFloat::ln(Self) -> Self
pub fn BinFloat::ln_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::log10(Self) -> Self
pub fn BinFloat::log10_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::log1p(Self) -> Self
pub fn BinFloat::log1p_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::log2(Self) -> Self
pub fn BinFloat::log2_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::logb_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::make(BinCoeff, Int, Int, negative? : Bool, mode? : @arithmetic.RoundingMode) -> Self
pub fn BinFloat::max(Self, Self) -> Self
pub fn BinFloat::min(Self, Self) -> Self
pub fn BinFloat::mul(Self, Self) -> Self
pub fn BinFloat::mul_contextual(Self, Self, @arithmetic.ArithmeticContext) -> Result[@arithmetic.ArithmeticOutcome[Self], @arithmetic.ArithmeticError]
pub fn BinFloat::mul_ctx(Self, Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::nan(precision? : Int) -> Self
pub fn BinFloat::nan_payload(Self) -> BinCoeff
pub fn BinFloat::neg(Self) -> Self
pub fn BinFloat::negative_zero(precision? : Int) -> Self
pub fn BinFloat::next_down_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::next_up_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::normalized(Self) -> Self
pub fn BinFloat::not_equal(Self, Self) -> Bool
pub fn BinFloat::one(precision? : Int) -> Self
pub fn BinFloat::op_ge(Self, Self) -> Bool
pub fn BinFloat::op_gt(Self, Self) -> Bool
pub fn BinFloat::op_le(Self, Self) -> Bool
pub fn BinFloat::op_lt(Self, Self) -> Bool
pub fn BinFloat::output(Self, &Logger) -> Unit
pub fn BinFloat::pow(Self, Self) -> Self
pub fn BinFloat::pow_ctx(Self, Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::pow_int(Self, Int) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BinFloat::pow_int_checked(Self, Int, @arithmetic.ArithmeticContext) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BinFloat::pow_int_ctx(Self, Int, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::pow_nat_checked(Self, UInt, @arithmetic.ArithmeticContext) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BinFloat::pown(Self, Int) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BinFloat::pown_ctx(Self, Int, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::precision(Self) -> Int
pub fn BinFloat::quiet_nan(payload? : BinCoeff, negative? : Bool, precision? : Int) -> Self
pub fn BinFloat::remainder(Self, Self) -> Self
pub fn BinFloat::remainder_ctx(Self, Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::rootn(Self, Int) -> Self
pub fn BinFloat::rootn_ctx(Self, Int, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::round(Self) -> Self
pub fn BinFloat::round_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::round_ties_even(Self) -> Self
pub fn BinFloat::scaleb_ctx(Self, Int, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::sign(Self) -> @def.Sign
pub fn BinFloat::signaling_nan(payload? : BinCoeff, negative? : Bool, precision? : Int) -> Self
pub fn BinFloat::sin(Self) -> Self
pub fn BinFloat::sin_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::sinh(Self) -> Self
pub fn BinFloat::sinh_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::sinpi(Self) -> Self
pub fn BinFloat::sinpi_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::sqrt(Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BinFloat::sqrt_checked(Self, @arithmetic.ArithmeticContext) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BinFloat::sqrt_contextual(Self, @arithmetic.ArithmeticContext) -> Result[@arithmetic.ArithmeticOutcome[Self], @arithmetic.ArithmeticError]
pub fn BinFloat::sqrt_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::sub(Self, Self) -> Self
pub fn BinFloat::sub_contextual(Self, Self, @arithmetic.ArithmeticContext) -> Result[@arithmetic.ArithmeticOutcome[Self], @arithmetic.ArithmeticError]
pub fn BinFloat::sub_ctx(Self, Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::tan(Self) -> Self
pub fn BinFloat::tan_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::tanh(Self) -> Self
pub fn BinFloat::tanh_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::tanpi(Self) -> Self
pub fn BinFloat::tanpi_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::to_decimal_string_ctx(Self, Int, BinaryContext) -> (String, BinaryFlags)
pub fn BinFloat::to_hex(Self) -> String
pub fn BinFloat::to_int64_ctx(Self, BinaryContext, exact? : Bool) -> (Int64?, BinaryFlags)
pub fn BinFloat::to_int_ctx(Self, BinaryContext, exact? : Bool) -> (Int?, BinaryFlags)
pub fn BinFloat::to_integral_exact_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::to_integral_value_ctx(Self, BinaryContext) -> (Self, BinaryFlags)
pub fn BinFloat::to_interchange(Self, BinaryInterchangeFormat, rounding? : BinaryRoundingMode, tininess? : TininessDetection) -> (BinaryInterchange, BinaryFlags)
pub fn BinFloat::to_repr(Self) -> @debug.Repr
pub fn BinFloat::to_shortest_string(Self) -> String
pub fn BinFloat::to_shortest_string_ctx(Self, BinaryContext) -> String
pub fn BinFloat::to_string(Self) -> String
pub fn BinFloat::to_uint64_ctx(Self, BinaryContext, exact? : Bool) -> (UInt64?, BinaryFlags)
pub fn BinFloat::to_uint_ctx(Self, BinaryContext, exact? : Bool) -> (UInt?, BinaryFlags)
pub fn BinFloat::total_order(Self, Self) -> Bool
pub fn BinFloat::total_order_compare(Self, Self) -> Int
pub fn BinFloat::total_order_mag(Self, Self) -> Bool
pub fn BinFloat::trunc(Self) -> Self
pub fn BinFloat::try_acos_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::try_acosh_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::try_asin_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::try_asinh_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::try_atan2_ctx(Self, Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::try_atan_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::try_atanh_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::try_cos_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::try_cosh_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::try_cospi_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::try_exp10_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::try_exp2_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::try_exp_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::try_exp_ln_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::try_expm1_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::try_hypot_ctx(Self, Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::try_ln_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::try_log10_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::try_log1p_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::try_log2_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::try_pow_ctx(Self, Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::try_rootn_ctx(Self, Int, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::try_sin_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::try_sinh_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::try_sinpi_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::try_tan_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::try_tanh_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::try_tanpi_ctx(Self, BinaryContext) -> Result[(Self, BinaryFlags), @arithmetic.ArithmeticError]
pub fn BinFloat::ulp(Self) -> Self
pub fn BinFloat::unordered_quiet(Self, Self) -> (Bool, BinaryFlags)
pub fn BinFloat::with_precision(Self, Int, @arithmetic.RoundingMode) -> Self
pub fn BinFloat::zero(precision? : Int) -> Self
pub impl @arithmetic.AbsContextual for BinFloat
pub impl @arithmetic.AddContextual for BinFloat
pub impl @arithmetic.CompareChecked for BinFloat
pub impl @arithmetic.DivChecked for BinFloat
pub impl @arithmetic.DivContextual for BinFloat
pub impl @arithmetic.ExpContextual for BinFloat
pub impl @arithmetic.MulContextual for BinFloat
pub impl @arithmetic.PowIntChecked for BinFloat
pub impl @arithmetic.PowNatChecked for BinFloat
pub impl @arithmetic.SqrtChecked for BinFloat
pub impl @arithmetic.SqrtContextual for BinFloat
pub impl @arithmetic.SubContextual for BinFloat
pub impl @def.Floating for BinFloat
pub impl Add for BinFloat
pub impl Compare for BinFloat
pub impl Div for BinFloat
pub impl Mul for BinFloat
pub impl Neg for BinFloat
pub impl Show for BinFloat
pub impl Sub for BinFloat

pub struct BinaryContext {
  // private fields
} derive(Eq, @debug.Debug)
pub fn BinaryContext::binary128(rounding? : BinaryRoundingMode, tininess? : TininessDetection) -> Self
pub fn BinaryContext::binary16(rounding? : BinaryRoundingMode, tininess? : TininessDetection) -> Self
pub fn BinaryContext::binary32(rounding? : BinaryRoundingMode, tininess? : TininessDetection) -> Self
pub fn BinaryContext::binary64(rounding? : BinaryRoundingMode, tininess? : TininessDetection) -> Self
pub fn BinaryContext::e_max(Self) -> Int?
pub fn BinaryContext::e_min(Self) -> Int?
pub fn BinaryContext::equal(Self, Self) -> Bool
pub fn BinaryContext::from_arithmetic_context(@arithmetic.ArithmeticContext) -> Self
pub fn BinaryContext::new(Int, rounding? : BinaryRoundingMode, e_min? : Int, e_max? : Int, tininess? : TininessDetection) -> Self
pub fn BinaryContext::not_equal(Self, Self) -> Bool
pub fn BinaryContext::precision(Self) -> Int
pub fn BinaryContext::rounding(Self) -> BinaryRoundingMode
pub fn BinaryContext::tininess(Self) -> TininessDetection
pub fn BinaryContext::to_repr(Self) -> @debug.Repr
pub fn BinaryContext::try_new(Int, rounding? : BinaryRoundingMode, e_min? : Int, e_max? : Int, tininess? : TininessDetection) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BinaryContext::unbounded(Int, rounding? : BinaryRoundingMode) -> Self

pub struct BinaryFlags {
  // private fields
} derive(Eq, @debug.Debug)
pub fn BinaryFlags::combine(Self, Self) -> Self
pub fn BinaryFlags::division_by_zero(Self) -> Bool
pub fn BinaryFlags::equal(Self, Self) -> Bool
pub fn BinaryFlags::inexact(Self) -> Bool
pub fn BinaryFlags::invalid_operation(Self) -> Bool
pub fn BinaryFlags::new() -> Self
pub fn BinaryFlags::not_equal(Self, Self) -> Bool
pub fn BinaryFlags::overflow(Self) -> Bool
pub fn BinaryFlags::to_repr(Self) -> @debug.Repr
pub fn BinaryFlags::to_testfloat_bits(Self) -> Int
pub fn BinaryFlags::underflow(Self) -> Bool

pub struct BinaryInterchange {
  // private fields
} derive(Eq)
pub fn BinaryInterchange::bits(Self) -> BinCoeff
pub fn BinaryInterchange::equal(Self, Self) -> Bool
pub fn BinaryInterchange::format(Self) -> BinaryInterchangeFormat
pub fn BinaryInterchange::from_bin_float(BinFloat, BinaryInterchangeFormat, rounding? : BinaryRoundingMode, tininess? : TininessDetection) -> (Self, BinaryFlags)
pub fn BinaryInterchange::from_bits(BinCoeff, BinaryInterchangeFormat) -> Self
pub fn BinaryInterchange::from_hex(String, BinaryInterchangeFormat) -> Self?
pub fn BinaryInterchange::not_equal(Self, Self) -> Bool
pub fn BinaryInterchange::to_bin_float(Self) -> BinFloat
pub fn BinaryInterchange::to_hex(Self) -> String

pub(all) enum BinaryInterchangeFormat {
  Binary16
  Binary32
  Binary64
  Binary128
} derive(Eq, @debug.Debug)
pub fn BinaryInterchangeFormat::bias(Self) -> Int
pub fn BinaryInterchangeFormat::context(Self, rounding? : BinaryRoundingMode, tininess? : TininessDetection) -> BinaryContext
pub fn BinaryInterchangeFormat::e_max(Self) -> Int
pub fn BinaryInterchangeFormat::e_min(Self) -> Int
pub fn BinaryInterchangeFormat::equal(Self, Self) -> Bool
pub fn BinaryInterchangeFormat::exponent_bits(Self) -> Int
pub fn BinaryInterchangeFormat::fraction_bits(Self) -> Int
pub fn BinaryInterchangeFormat::not_equal(Self, Self) -> Bool
pub fn BinaryInterchangeFormat::precision(Self) -> Int
pub fn BinaryInterchangeFormat::to_repr(Self) -> @debug.Repr
pub fn BinaryInterchangeFormat::total_bits(Self) -> Int

pub(all) enum BinaryRoundingMode {
  RoundTiesToEven
  RoundTiesToAway
  RoundTowardZero
  RoundTowardPositive
  RoundTowardNegative
  RoundAwayFromZero
} derive(Eq, @debug.Debug)
pub fn BinaryRoundingMode::equal(Self, Self) -> Bool
pub fn BinaryRoundingMode::from_arithmetic(@arithmetic.RoundingMode) -> Self
pub fn BinaryRoundingMode::not_equal(Self, Self) -> Bool
pub fn BinaryRoundingMode::to_arithmetic(Self) -> @arithmetic.RoundingMode?
pub fn BinaryRoundingMode::to_repr(Self) -> @debug.Repr

pub(all) enum TininessDetection {
  BeforeRounding
  AfterRounding
} derive(Eq, @debug.Debug)
pub fn TininessDetection::equal(Self, Self) -> Bool
pub fn TininessDetection::not_equal(Self, Self) -> Bool
pub fn TininessDetection::to_repr(Self) -> @debug.Repr

// Type aliases

// Traits

bin_float API

调用运算的三种方式

值与限制

binary_implementation_e_max, binary_implementation_e_min

binary_precision_max

精确系数

BinCoeff

BinCoeff::zero, BinCoeff::one, BinCoeff::from_uint64

BinCoeff::parse, BinCoeff::to_string, BinCoeff::to_radix_string

BinCoeff::from_bytes_be, BinCoeff::to_bytes_be

BinCoeff::to_uint64

BinCoeff::is_zero, BinCoeff::bit_length, BinCoeff::ctz, BinCoeff::test_bit

BinCoeff::compare, BinCoeff::equal

BinCoeff::add, BinCoeff::mul, BinCoeff::square, BinCoeff::pow_nat

BinCoeff::sub_checked, BinCoeff::div_rem_checked

BinCoeff::gcd

BinCoeff::shift_left, BinCoeff::shift_right, BinCoeff::shl, BinCoeff::shr

BinCoeff::bit_and, BinCoeff::bit_or, BinCoeff::bit_xor

BinCoeff 的 trait 实现

值类型

BinFloat

BinFloat::make

BinFloat::from_coefficient, BinFloat::from_int

BinFloat::from_double, BinFloat::from_float

BinFloat::zero, BinFloat::negative_zero, BinFloat::one, BinFloat::inf

BinFloat::nan, BinFloat::quiet_nan, BinFloat::signaling_nan

观察值

BinFloat::classify, BinFloat::sign, BinFloat::is_negative

BinFloat::is_zero, BinFloat::is_negative_zero, BinFloat::is_quiet_nan, BinFloat::is_signaling_nan, BinFloat::nan_payload

BinFloat::coefficient, BinFloat::exponent2, BinFloat::precision

BinFloat::normalized

BinFloat::with_precision

BinFloat::ulp

普通算术

BinFloat::add, BinFloat::sub, BinFloat::mul, BinFloat::div, BinFloat::neg

BinFloat::abs, BinFloat::copy_sign

BinFloat::div_checked

BinFloat::sqrt, sqrt_for_precision, sqrt_bounds_for_precision

BinFloat::pow_int, BinFloat::pown

BinFloat::fma

BinFloat::remainder