`ball_float` API

ball_float 是以 BinFloat 为端点的区间算术。BallFloat 是一个闭实数区间 $[\underline{x}, \overline{x}]$ （可以无界），或者空集；每个运算返回的区间都包含该运算作用于操作数中各点时的全部精确结果（即包含性质）。BallFloatDecorated 增加了 IEEE 1788-2015 的装饰（decoration），BallContext 将结果舍入到目标二进制格式并报告 BallFlags。

虽然名字叫“球”，其存储表示却是端点对，而不是中点与半径：BallFloat::new(center, radius)、center() 和 radius() 负责与中点–半径视图之间的相互转换。教程展示了典型用法；设计文档推导了相关公式并证明了包含性质。

本页使用的约定：

$\operatorname{RD}_p$ 和 $\operatorname{RU}_p$ 分别向 $-\infty$ 和 $+\infty$ 舍入到 $p$ 位有效二进制位。“向外舍入”是指下端点用 $\operatorname{RD}_p$ 舍入、上端点用 $\operatorname{RU}_p$ 舍入。
区间的精度是一个以位为单位的标记。运算会将结果向外舍入到其操作数中较大的那个精度；初等函数使用其参数的精度。
BinFloat 端点的指数范围就是 bin_float 的二进制实现范围，远比任何交换格式宽。如需施加更窄的范围，请使用 BallContext。
Empty 表示空集，Entire 表示 $(-\infty, +\infty)$ 。无界区间以 $-\infty$ 和/或 $+\infty$ 作为端点存储；这仅表示集合在该侧无界，绝不表示它包含无穷值。

本页示例使用以下辅助函数：

///|
fn iv(lo : Int, hi : Int) -> @ball_float.BallFloat {
  @ball_float.BallFloat::from_bounds(
    @bin_float.BinFloat::from_int(lo, precision=53),
    @bin_float.BinFloat::from_int(hi, precision=53),
  )
}

///|
fn fmt(x : @ball_float.BallFloat) -> String {
  if x.is_empty() {
    return "[empty]"
  }
  let down = @bin_float.BinaryContext::unbounded(
    53,
    rounding=@bin_float.BinaryRoundingMode::RoundTowardNegative,
  )
  let up = @bin_float.BinaryContext::unbounded(
    53,
    rounding=@bin_float.BinaryRoundingMode::RoundTowardPositive,
  )
  "[" +
  x.lower_bound().to_decimal_string_ctx(6, down).0 +
  ", " +
  x.upper_bound().to_decimal_string_ctx(6, up).0 +
  "]"
}

类型

`BallFloat`

BallFloat 是一个以 BinFloat 为端点并带有精度标记的闭区间。

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

非空值满足 $\underline{x} \le \overline{x}$ ，没有 NaN 端点，绝不会出现 $\underline{x} = +\infty$ 或 $\overline{x} = -\infty$ ，且精度 $\ge 1$ 。空集是一个单独的状态。字段是私有的；请使用构造中的函数构造值。派生的 Eq 比较的是存储表示（端点和精度），而不是集合；参见 BallFloat::set_equal。

`BallFloatDecorated`

BallFloatDecorated 是一个 BallFloat 与一个 IEEE 1788 Decoration 的组合，或者是特殊值 NaI（not an interval，非区间）。

pub struct BallFloatDecorated {
  // private fields
} derive(Eq)

装饰始终保持规范形式：空区间总是带有 Trv，无界区间绝不带有 Com，并且只有 BallFloatDecorated::nai 带有 Ill。

`Decoration`

Decoration 是装饰区间的 IEEE 1788 装饰，其顺序为 Ill < Trv < Def < Dac < Com。

pub(all) enum Decoration {
  Ill
  Trv
  Def
  Dac
  Com
} derive(Eq, @debug.Debug)

对于函数 $f$ 在 $\boldsymbol{x}$ 上求值所得的装饰结果 $(\boldsymbol{y}, d)$ ：

构造子	含义
`Com`	$f$ 在 $\boldsymbol{x}$ 上有定义且连续，并且 $\boldsymbol{y}$ 有界
`Dac`	$f$ 在 $\boldsymbol{x}$ 上有定义且连续
`Def`	$f$ 在 $\boldsymbol{x}$ 上有定义
`Trv`	一无所知
`Ill`	值为 NaI

Show 输出 IEEE 1788 的小写名称 com、dac、def、trv、ill。

`OverlapState`

OverlapState 是 overlap_state 的结果：IEEE 1788 对两个区间相对位置的分类。

pub(all) enum OverlapState {
  Undefined
  BothEmpty
  FirstEmpty
  SecondEmpty
  Before
  Meets
  OverlapsState
  Starts
  ContainedBy
  Finishes
  EqualIntervals
  After
  MetBy
  OverlappedBy
  StartedBy
  ContainsInterval
  FinishedBy
} derive(Eq, @debug.Debug)

这些构造子对应 IEEE 1788 的状态 bothEmpty、firstEmpty、secondEmpty、before、meets、overlaps、starts、containedBy、finishes、equal、after、metBy、overlappedBy、startedBy、contains 和 finishedBy；OverlapsState、EqualIntervals 和 ContainsInterval 带有后缀，只是为了避免与方法名冲突。仅当操作数为 NaI 时，装饰版本才会返回 Undefined。

`BallContext`

BallContext 描述一个目标二进制格式：以位为单位的精度和指数范围 $[e_{\min}, e_{\max}]$ 。

pub struct BallContext {
  // private fields
}

$e_{\min}$ 和 $e_{\max}$ 遵循 IEEE 754：满足 $2^{e} \le |v| < 2^{e+1}$ 的有限非零值 $v$ ，当 $e \le e_{\max}$ 时在范围内，当 $e \ge e_{\min}$ 时为正规数。参见上下文与标志。

`BallFlags`

BallFlags 记录将区间舍入到某个 BallContext 时触发的条件。

pub struct BallFlags {
  inexact : Bool
  overflow : Bool
  underflow : Bool
} derive(Eq)

当端点发生改变时设置 inexact；当端点超出 $e_{\max}$ 时设置 overflow；当端点低于正规范围且其次正规数舍入不精确时设置 underflow。这些字段可读；访问器方法列于 BallFlags 之下。

构造

`BallFloat::new`

BallFloat::new 由中心和半径构建区间 $[c - r, c + r]$ ，并适当扩大以使其在所请求的精度下可精确表示。

pub fn BallFloat::new(@bin_float.BinFloat, @bin_float.BinFloat, precision? : Int) -> Self

默认精度是 center 与 radius 精度中的较大者。记该精度为 $p$ ，则存储的区间为

[\tilde c - R,\; \tilde c + R], \qquad \tilde c = \operatorname{RN}_p(c),\quad R = \operatorname{RU}_p\bigl(\operatorname{RU}_p(r) + \operatorname{RU}_p(|c - \tilde c|)\bigr),

它包含 $[c - r, c + r]$ （证明见设计文档）。端点 $\tilde c \pm R$ 是精确构成的，因此其位数可能多于 $p$ 。当 center 或 radius 非有限，或 radius 为负时中止。小于 1 的精度按 1 处理。

`BallFloat::from_bounds` 与 `BallFloat::try_from_bounds`

BallFloat::from_bounds 由端点构建区间 $[\underline{x}, \overline{x}]$ ，并向外舍入到所请求的精度。

pub fn BallFloat::from_bounds(@bin_float.BinFloat, @bin_float.BinFloat, precision? : Int) -> Self
pub fn BallFloat::try_from_bounds(@bin_float.BinFloat, @bin_float.BinFloat, precision? : Int) -> Result[Self, @arithmetic.ArithmeticError]

默认精度是两个端点精度中的较大者。无穷端点构建无界区间：from_bounds(-inf, +inf) 即 Entire。当某个端点为 NaN、下端点为 $+\infty$ 、上端点为 $-\infty$ 或 $\underline{x} > \overline{x}$ 时，输入无效；此时 from_bounds 中止，try_from_bounds 返回定义域错误。无法由端点构建 Empty；请使用 BallFloat::empty。

///|
test "from_bounds" {
  let two = @bin_float.BinFloat::from_int(2, precision=53)
  let three = @bin_float.BinFloat::from_int(3, precision=53)
  inspect(fmt(@ball_float.BallFloat::from_bounds(two, three)), content="[2.00000e+0, 3.00000e+0]")
  inspect(@ball_float.BallFloat::try_from_bounds(three, two) is Err(_), content="true")
}

`BallFloat::exact` 与 `BallFloat::try_exact`

BallFloat::exact 构建有限 BinFloat 的单点集 $\{x\}$ 。

pub fn BallFloat::exact(@bin_float.BinFloat, precision? : Int) -> Self
pub fn BallFloat::try_exact(@bin_float.BinFloat, precision? : Int) -> Result[Self, @arithmetic.ArithmeticError]

默认精度为 x 的精度。当 x 的有效位数多于所请求的精度时，单点集会向外舍入为包围 x 的两点区间。非有限的 x 会使 exact 中止，并使 try_exact 返回定义域错误。

`BallFloat::from_int` 与 `BallFloat::from_coefficient`

BallFloat::from_int 和 BallFloat::from_coefficient 构建整数的单点集。

pub fn BallFloat::from_int(Int, precision? : Int) -> Self
pub fn BallFloat::from_coefficient(@bin_float.BinCoeff, precision? : Int, negative? : Bool) -> Self

默认精度为 16。from_coefficient 接受一个非负的 BinCoeff 绝对值和单独的符号。整数先以就近舍入转换为 $\max(p, 8)$ 位的 BinFloat，再用 exact 嵌入。

`BallFloat::from_double`、`BallFloat::from_float` 及其 `try_` 形式

这些函数构建 Double 或 Float 的精确二进制值的单点集。

pub fn BallFloat::from_double(Double, precision? : Int) -> Self
pub fn BallFloat::try_from_double(Double, precision? : Int) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::from_float(Float, precision? : Int) -> Self
pub fn BallFloat::try_from_float(Float, precision? : Int) -> Result[Self, @arithmetic.ArithmeticError]

默认精度分别为 53 和 24。到 BinFloat 的转换是精确的；若请求的精度更小，则单点集会向外舍入。NaN 和无穷会使普通形式中止，对 try_ 形式则是定义域错误。结果包络的是二进制值，而不是书写时的十进制字面量：from_double(0.1) 不包含 $1/10$ 。

`BallFloat::whole` 与 `BallFloat::empty`

BallFloat::whole 返回 Entire，BallFloat::empty 返回 Empty。

pub fn BallFloat::whole(precision? : Int) -> Self
pub fn BallFloat::empty(precision? : Int) -> Self

默认精度为 53。

观察函数

`BallFloat::lower_bound` 与 `BallFloat::upper_bound`

lower_bound 和 upper_bound 返回存储的端点。

pub fn BallFloat::lower_bound(Self) -> @bin_float.BinFloat
pub fn BallFloat::upper_bound(Self) -> @bin_float.BinFloat

在无界的一侧，端点是无穷。对于 Empty，二者分别返回 $+\infty$ 和 $-\infty$ ，因此请先检查 is_empty。

`BallFloat::center` 与 `BallFloat::radius`

center 和 radius 返回有界区间的中点–半径视图。

pub fn BallFloat::center(Self) -> @bin_float.BinFloat
pub fn BallFloat::radius(Self) -> @bin_float.BinFloat

center 为 $(\underline{x} + \overline{x})/2$ ，radius 为 $(\overline{x} - \underline{x})/2$ ，二者均精确计算（仅当半径低于指数范围下溢时才向上舍入），因此 $[\text{center} - \text{radius}, \text{center} + \text{radius}]$ 就是存储的区间。二者在 Empty 和无界区间上均会中止。

`BallFloat::midpoint`

midpoint 返回以区间精度就近舍入后的中心。

pub fn BallFloat::midpoint(Self) -> @bin_float.BinFloat

Entire 的中点为 0。Empty 和半无界区间会中止。

`BallFloat::width` 与 `BallFloat::radius_extended`

width 返回 $\operatorname{RU}_p(\overline{x} - \underline{x})$ ，radius_extended 返回向上舍入到区间精度的半径。

pub fn BallFloat::width(Self) -> @bin_float.BinFloat
pub fn BallFloat::radius_extended(Self) -> @bin_float.BinFloat

二者对 Empty 返回 0，对无界区间返回 $+\infty$ ，而不会中止。

`BallFloat::magnitude` 与 `BallFloat::mignitude`

magnitude 返回 $\max\{|\xi| : \xi \in \boldsymbol{x}\}$ ，mignitude 返回 $\min\{|\xi| : \xi \in \boldsymbol{x}\}$ 。

pub fn BallFloat::magnitude(Self) -> @bin_float.BinFloat
pub fn BallFloat::mignitude(Self) -> @bin_float.BinFloat

二者均为精确的。Empty 给出 0；当区间包含 0 时 mignitude 为 0；无界区间的 magnitude 为 $+\infty$ 。

///|
test "observers" {
  let x = iv(-3, 5)
  inspect(x.center().to_string(), content="1p0")
  inspect(x.radius().to_string(), content="1p2")
  inspect(x.width().to_string(), content="1p3")
  inspect(x.magnitude().to_string(), content="5p0")
  inspect(x.mignitude().to_string(), content="0")
  inspect(iv(2, 7).mignitude().to_string(), content="1p1")
}

`BallFloat::precision`、`BallFloat::classify` 与 `BallFloat::sign`

precision 返回精度标记；classify 和 sign 用标量浮点类型的术语描述区间。

pub fn BallFloat::precision(Self) -> Int
pub fn BallFloat::classify(Self) -> @arithmetic.FpClass
pub fn BallFloat::sign(Self) -> @def.Sign

classify 对 Empty 返回 NaN，对有界区间返回 Finite，对无界区间返回 Infinity。sign 在 $\underline{x} > 0$ 时返回 Positive，在 $\overline{x} < 0$ 时返回 Negative，否则返回 Zero：Zero 表示“区间包含 0”，而不是“区间为 $\{0\}$ ”。sign 在 Empty 上中止。

形状谓词

is_empty、is_entire、is_bounded、is_common_interval、is_singleton 和 contains_zero 检测集合的形状。

pub fn BallFloat::is_empty(Self) -> Bool
pub fn BallFloat::is_entire(Self) -> Bool
pub fn BallFloat::is_bounded(Self) -> Bool
pub fn BallFloat::is_common_interval(Self) -> Bool
pub fn BallFloat::is_singleton(Self) -> Bool
pub fn BallFloat::contains_zero(Self) -> Bool

is_bounded 与 is_common_interval（IEEE 1788 中的名称）相同：区间非空且两个端点均有限。当 $\underline{x} = \overline{x}$ 时 is_singleton 成立。对 Empty，contains_zero 为假。

精度

`BallFloat::with_precision`

with_precision 将区间重新舍入到新的精度，且不会使其缩小。

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

对于有界区间，中心按 mode 舍入，所产生的偏移加到半径上，然后像 BallFloat::new 那样重建结果。对于无界区间，有限端点向外舍入，mode 被忽略。Empty 仍为 Empty，但带上新的精度。结果总是包含输入，唯一的例外是 center 中提到的极端情形，即新精度超过约 $2^{16}$ 位时。

`BallFloat::normalized`

normalized 由规范化后的中心和半径重建有界区间（BinFloat::normalized 会去除末尾的零位），并将无界区间的有限端点向外重新舍入。

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

结果包含输入。

集合运算

`BallFloat::intersection` 与 `BallFloat::convex_hull`

intersection 返回 $\boldsymbol{x} \cap \boldsymbol{y}$ ，convex_hull 返回包含 $\boldsymbol{x} \cup \boldsymbol{y}$ 的最小区间。

pub fn BallFloat::intersection(Self, Self) -> Self
pub fn BallFloat::convex_hull(Self, Self) -> Self

二者都通过端点的 max/min 计算，除最后向外舍入到较大精度之外都是精确的。不相交区间的交为 Empty；Empty 是 convex_hull 的单位元。

`BallFloat::cancel_plus` 与 `BallFloat::cancel_minus`

cancel_minus(x, y) 返回满足 $\boldsymbol{y} + \boldsymbol{z} = \boldsymbol{x}$ 的区间 $\boldsymbol{z}$ ，即用于撤销先前求和的加法逆运算；cancel_plus(x, y) 即 cancel_minus(x, -y)。

pub fn BallFloat::cancel_plus(Self, Self) -> Self
pub fn BallFloat::cancel_minus(Self, Self) -> Self

对于有界操作数，cancel_minus 为向外舍入的 $[\underline{x} - \underline{y}, \overline{x} - \overline{y}]$ 。当它不构成区间（ $\boldsymbol{y}$ 的宽度超过 $\boldsymbol{x}$ 的宽度）、当有操作数无界、或当仅 $\boldsymbol{y}$ 为空时，结果为 Entire。 $\boldsymbol{x}$ 为 Empty 而 $\boldsymbol{y}$ 有界或为空时，结果为 Empty。

///|
test "set operations" {
  inspect(fmt(iv(0, 4).intersection(iv(2, 9))), content="[2.00000e+0, 4.00000e+0]")
  inspect(iv(0, 1).intersection(iv(2, 3)).is_empty(), content="true")
  inspect(fmt(iv(0, 1).convex_hull(iv(5, 6))), content="[0.00000e+0, 6.00000e+0]")
  // (x + y) - y widens, cancel_minus recovers x.
  let x = iv(1, 2)
  let y = iv(10, 20)
  inspect(fmt(x + y - y), content="[-9.00000e+0, 1.20000e+1]")
  inspect(fmt((x + y).cancel_minus(y)), content="[1.00000e+0, 2.00000e+0]")
}

关系

所有关系都是 IEEE 1788 的集合关系；它们都不是全序。它们从不中止。

`BallFloat::contains`

contains 检测一个点是否属于该区间。

pub fn BallFloat::contains(Self, @bin_float.BinFloat) -> Bool

对 Empty 和非有限的点，它返回假（无界区间包含所有足够大的实数，但不包含 $\pm\infty$ 或 NaN）。trait 方法 @lf_arith.Contains::contains 则接受两个区间并检测包含关系；参见 trait 实现。

`BallFloat::subset`, `BallFloat::interior`, `BallFloat::set_equal`, `BallFloat::disjoint`

这些函数检测集合的包含、内部包含、相等与不相交。

pub fn BallFloat::subset(Self, Self) -> Bool
pub fn BallFloat::interior(Self, Self) -> Bool
pub fn BallFloat::set_equal(Self, Self) -> Bool
pub fn BallFloat::disjoint(Self, Self) -> Bool

x.subset(y) 即 $\boldsymbol{x} \subseteq \boldsymbol{y}$ ，x.interior(y) 即 $\boldsymbol{x} \subseteq \operatorname{int} \boldsymbol{y}$ ，其中无穷端点视为位于内部（因此 Entire 在其自身内部）。Empty 是任何区间的子集、位于任何区间内部，并且与任何区间不相交。set_equal 忽略精度标记和端点的表示方式。

`BallFloat::overlaps`, `BallFloat::maybe_eq`, `BallFloat::separated_from`

overlaps 检测两个区间是否有公共点；maybe_eq 是同一关系，但解读为“两个未知点可能相等”；separated_from 是其否定。

pub fn BallFloat::overlaps(Self, Self) -> Bool
pub fn BallFloat::maybe_eq(Self, Self) -> Bool
pub fn BallFloat::separated_from(Self, Self) -> Bool

当有操作数为 Empty 时，overlaps 为假，separated_from 为真。

`BallFloat::definitely_lt`, `BallFloat::definitely_le`, `BallFloat::definitely_gt`

当所有点对都满足该序关系时，这些关系才成立。

pub fn BallFloat::definitely_lt(Self, Self) -> Bool
pub fn BallFloat::definitely_le(Self, Self) -> Bool
pub fn BallFloat::definitely_gt(Self, Self) -> Bool

x.definitely_lt(y) 即 $\overline{x} < \underline{y}$ ，definitely_le 即 $\overline{x} \le \underline{y}$ ，definitely_gt 即 $\underline{x} > \overline{y}$ 。当有操作数为 Empty 时三者均为假（与 precedes 不同，后者此时空真）。

`BallFloat::less`, `BallFloat::strictly_less`, `BallFloat::precedes`, `BallFloat::strictly_precedes`

这些是 IEEE 1788 的序关系。

pub fn BallFloat::less(Self, Self) -> Bool
pub fn BallFloat::strictly_less(Self, Self) -> Bool
pub fn BallFloat::precedes(Self, Self) -> Bool
pub fn BallFloat::strictly_precedes(Self, Self) -> Bool

对于非空操作数：

关系	条件
`less`	$\underline{x} \le \underline{y}$ 且 $\overline{x} \le \overline{y}$
`strictly_less`	$\underline{x} < \underline{y}$ （或二者均为 $-\infty$ ）且 $\overline{x} < \overline{y}$ （或二者均为 $+\infty$ ）
`precedes`	$\overline{x} \le \underline{y}$
`strictly_precedes`	$\overline{x} < \underline{y}$

涉及 Empty 时：less 和 strictly_less 仅当两者均为 Empty 时成立；precedes 和 strictly_precedes 在任一者为 Empty 时成立。

`BallFloat::overlap_state`

overlap_state 对两个区间的相对位置进行分类。

pub fn BallFloat::overlap_state(Self, Self) -> OverlapState

结果是 OverlapState 中除 Undefined 以外的十六种状态之一；它由四个端点之间的比较计算得出。

///|
test "relations" {
  let a = iv(1, 3)
  let b = iv(3, 6)
  inspect(a.precedes(b), content="true")
  inspect(a.strictly_precedes(b), content="false")
  inspect(a.definitely_le(b), content="true")
  inspect(a.maybe_eq(b), content="true")
  inspect(iv(2, 3).interior(iv(1, 6)), content="true")
  inspect(iv(1, 3).interior(iv(1, 6)), content="false")
  debug_inspect(a.overlap_state(b), content="Meets")
  debug_inspect(iv(1, 6).overlap_state(iv(2, 3)), content="ContainsInterval")
}

算术

`BallFloat::add`, `BallFloat::sub`, `BallFloat::mul`, `BallFloat::div`

四则基本运算返回 $\{\xi \circ \eta : \xi \in \boldsymbol{x}, \eta \in \boldsymbol{y}\}$ 向外舍入后的包；它们也可以通过运算符 +、-、*、/ 使用。

pub fn BallFloat::add(Self, Self) -> Self
pub fn BallFloat::sub(Self, Self) -> Self
pub fn BallFloat::mul(Self, Self) -> Self
pub fn BallFloat::div(Self, Self) -> Self

结果精度为操作数中较大的精度；有 Empty 操作数时结果为 Empty。端点公式如下：

\begin{aligned} \boldsymbol{x} + \boldsymbol{y} &= [\operatorname{RD}(\underline{x} + \underline{y}),\ \operatorname{RU}(\overline{x} + \overline{y})] \\ \boldsymbol{x} - \boldsymbol{y} &= [\operatorname{RD}(\underline{x} - \overline{y}),\ \operatorname{RU}(\overline{x} - \underline{y})] \\ \boldsymbol{x} \cdot \boldsymbol{y} &= [\operatorname{RD}\min S,\ \operatorname{RU}\max S],\quad S = \{\underline{x}\underline{y}, \underline{x}\overline{y}, \overline{x}\underline{y}, \overline{x}\overline{y}\} \end{aligned}

其中在 $S$ 中将 $0 \cdot \infty$ 取为 0（零端点乘以无界的一侧贡献 0）。对于有界操作数，由操作数的符号选出可能取到极值的两个乘积，因此最多只需计算两个乘积（当两个操作数都包含 0 时为四个）。

除法遵循 IEEE 1788： $\boldsymbol{x} / \boldsymbol{y}$ 是 $\{\xi/\eta : \eta \ne 0\}$ 的包。

除数 $\boldsymbol{y}$	结果
$0 \notin \boldsymbol{y}$	$[\operatorname{RD}\min Q, \operatorname{RU}\max Q]$ ，其中 $Q$ 取遍端点之商
$\{0\}$	Empty
$\underline{y} < 0 < \overline{y}$	Entire
$[0, \overline{y}]$ 或 $[\underline{y}, 0]$	半无界（见下文），当 $\underline{x} < 0 < \overline{x}$ 时为 Entire

当除数在一端触及 0 时，商在一侧无界：例如 $[1, 2]/[0, 4] = [1/4, +\infty)$ ， $[-2, -1]/[0, 4] = (-\infty, -1/4]$ 。被除数等于 $\{0\}$ 时，对除 $\{0\}$ 以外的任何除数都得到 $\{0\}$ 。

///|
test "basic arithmetic" {
  let x = iv(1, 2)
  let y = iv(-3, 5)
  inspect(fmt(x + y), content="[-2.00000e+0, 7.00000e+0]")
  inspect(fmt(x - y), content="[-4.00000e+0, 5.00000e+0]")
  inspect(fmt(x * y), content="[-6.00000e+0, 1.00000e+1]")
  inspect((x / y).is_entire(), content="true")
  inspect(fmt(x / iv(0, 4)), content="[2.50000e-1, inf]")
  inspect((x / iv(0, 0)).is_empty(), content="true")
}

`BallFloat::neg` 与 `BallFloat::abs`

neg 返回 $[-\overline{x}, -\underline{x}]$ ，abs 返回 $\{|\xi| : \xi \in \boldsymbol{x}\}$ 。

pub fn BallFloat::neg(Self) -> Self
pub fn BallFloat::abs(Self) -> Self

二者均为精确的。neg 也是一元运算符 -。

`BallFloat::reciprocal`

reciprocal 按上述除法规则返回 $1/\boldsymbol{x}$ 。

pub fn BallFloat::reciprocal(Self) -> Self

`BallFloat::square` 与 `BallFloat::pown`

square 返回 $\{\xi^2\}$ ，pown 对整数指数 $n$ 返回 $\{\xi^n\}$ 。

pub fn BallFloat::square(Self) -> Self
pub fn BallFloat::pown(Self, Int) -> Self

与 x * x 不同，这些函数两次使用的是同一个点，因此 [-1, 2].square() 为 $[0, 4]$ （而 x * x 为 $[-2, 4]$ ）。pown 以定向舍入在端点处计算 $\xi^n$ 的各单调分段：奇数正次幂递增；偶数正次幂先减后增，当 $0 \in \boldsymbol{x}$ 时最小值为 0；负次幂在 0 处有极点。对每个非空的 x，pown(x, 0) 为 $\{1\}$ ；Empty 仍为 Empty。当 $n < 0$ 时，pown(x, n) 对 $\boldsymbol{x} = \{0\}$ 返回 Empty，当 0 为端点时返回半无界区间，当 0 位于内部时返回 Entire（ $n$ 为奇数）或 $[\min(\underline{x}^n, \overline{x}^n), +\infty)$ （ $n$ 为偶数）。

///|
test "powers" {
  let x = iv(-1, 2)
  inspect(fmt(x.square()), content="[0.00000e+0, 4.00000e+0]")
  inspect(fmt(x.pown(3)), content="[-1.00000e+0, 8.00000e+0]")
  inspect(fmt(x.pown(-2)), content="[2.50000e-1, inf]")
  inspect(x.pown(-1).is_entire(), content="true")
  inspect(fmt(iv(0, 2).pown(-1)), content="[5.00000e-1, inf]")
}

`BallFloat::fma`

fma(x, y, z) 以单次向外舍入返回 $\{\xi\eta + \zeta\}$ 的一个包络。

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

乘积界按 mul 的方式计算，并在最终舍入之前加到 $\boldsymbol{z}$ 的端点上，因此结果绝不会比 x * y + z 更宽。

`BallFloat::minimum` 与 `BallFloat::maximum`

minimum 和 maximum 分别返回 $\{\min(\xi, \eta)\}$ 和 $\{\max(\xi, \eta)\}$ 。

pub fn BallFloat::minimum(Self, Self) -> Self
pub fn BallFloat::maximum(Self, Self) -> Self

minimum 为 $[\min(\underline{x}, \underline{y}), \min(\overline{x}, \overline{y})]$ ，maximum 则是将其中的 min 换成 max 的类似形式。有 Empty 操作数时结果为 Empty。

初等函数

每个函数 $f$ 返回一个包含 $f(\boldsymbol{x} \cap D_f)$ 的区间，其中 $D_f$ 是 $f$ 的定义域； $\boldsymbol{x}$ 中位于 $D_f$ 之外的点被忽略，当 $\boldsymbol{x} \cap D_f$ 为空时结果为 Empty。结果精度为参数的精度。

函数有两种形式。全函数形式（exp_interval、sin_interval 等）总是返回有效的包络；当认证求值耗尽其细化预算时，它返回一个更宽但仍然有效的区间。try_ 形式（try_exp_interval 等）在这种情况下返回 Err(ArithmeticError)，并附带指明运算、阶段和原因的认证失败详情。除另有说明外，try_ 形式使用对应的 bin_float try_*_ctx 函数，以向 $-\infty$ 或 $+\infty$ 舍入的方式对每个端点求值；全函数形式则要么调用这些函数，要么使用本包中的认证级数。在普通输入上两种形式返回相同的集合；它们的界可能相差一个 ulp。

`BallFloat::sqrt_interval`

sqrt_interval 返回 $\sqrt{\boldsymbol{x} \cap [0, +\infty)}$ 。

pub fn BallFloat::sqrt_interval(Self) -> Self

端点是区间精度下向下和向上舍入的平方根。当 $\overline{x} < 0$ 时为 Empty。没有 try_ 形式：平方根从不失败。

指数函数

exp_interval、exp2_interval、exp10_interval 和 expm1_interval 分别返回 $e^{\xi}$ 、 $2^{\xi}$ 、 $10^{\xi}$ 和 $e^{\xi} - 1$ 的包络。

pub fn BallFloat::exp_interval(Self) -> Self
pub fn BallFloat::exp2_interval(Self) -> Self
pub fn BallFloat::exp10_interval(Self) -> Self
pub fn BallFloat::expm1_interval(Self) -> Self
pub fn BallFloat::try_exp_interval(Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_exp2_interval(Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_exp10_interval(Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_expm1_interval(Self) -> Result[Self, @arithmetic.ArithmeticError]

四者都是递增的，因此结果为 $[\operatorname{RD} f(\underline{x}), \operatorname{RU} f(\overline{x})]$ 。exp_interval 使用带参数折半的认证 Taylor 级数，从不需要回退；当 $|\xi| \ge 2^{30}$ 时，它返回 $[\text{largest finite}, +\infty)$ 或 $[0, \text{smallest positive}]$ 。exp2_interval 和 exp10_interval 以多 96 位的精度计算 $e^{\xi \ln b}$ ，并对整数端点返回精确的幂（对 exp10_interval，指数需满足 $0 \le n \le 100000$ ）。全函数形式的 expm1_interval 回退为 $[-1, +\infty)$ 。

对数函数

ln_interval、log2_interval、log10_interval 和 log1p_interval 分别在其定义域 $(0, \infty)$ 和 $(-1, \infty)$ 上返回 $\ln \xi$ 、 $\log_2 \xi$ 、 $\log_{10} \xi$ 和 $\ln(1 + \xi)$ 的包络。

pub fn BallFloat::ln_interval(Self) -> Self
pub fn BallFloat::log2_interval(Self) -> Self
pub fn BallFloat::log10_interval(Self) -> Self
pub fn BallFloat::log1p_interval(Self) -> Self
pub fn BallFloat::try_ln_interval(Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_log2_interval(Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_log10_interval(Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_log1p_interval(Self) -> Result[Self, @arithmetic.ArithmeticError]

当区间到达定义域边界（ $\underline{x} \le 0$ ，对 log1p 为 $\underline{x} \le -1$ ）时，下端点为 $-\infty$ ；当区间完全位于定义域之外时，结果为 Empty。log10_interval 在端点 $10^k$ （ $0 \le k \le 9$ ）处返回精确整数。全函数形式的 log1p_interval 回退为 Entire。

///|
test "exponentials and logarithms" {
  inspect(fmt(iv(0, 1).exp_interval()), content="[1.00000e+0, 2.71829e+0]")
  inspect(fmt(iv(-1, 10).exp2_interval()), content="[5.00000e-1, 1.02400e+3]")
  inspect(fmt(iv(0, 4).ln_interval()), content="[-inf, 1.38630e+0]")
  inspect(fmt(iv(1, 1000).log10_interval()), content="[0.00000e+0, 3.00000e+0]")
  inspect(iv(-2, -1).ln_interval().is_empty(), content="true")
}

`BallFloat::pow_interval` 与 `BallFloat::try_pow_interval`

pow_interval(x, y) 在 IEEE 1788 中 pow 的定义域（ $\xi > 0$ ，或 $\xi = 0$ 且 $\eta > 0$ ）上返回 $\{\xi^{\eta} : \xi \in \boldsymbol{x}, \eta \in \boldsymbol{y}\}$ 的包络。

pub fn BallFloat::pow_interval(Self, Self) -> Self
pub fn BallFloat::try_pow_interval(Self, Self) -> Result[Self, @arithmetic.ArithmeticError]

底数的负值部分被忽略（负底数请使用 pown 或 rootn）。结果是四个角点值的包，并且：当底数区间包含 1 或指数区间包含 0 时扩展到 1；当底数到达 0 且指数为正时扩展到 0；当底数到达 0 且指数为负时扩展到 $+\infty$ 。 $\eta \le 0$ 时的 $0^{\eta}$ 被排除，因此当 $\overline{y} \le 0$ 时 pow_interval([0, 0], y) 为 Empty。结果精度为操作数中较大的精度。全函数形式回退为以多 192 位的精度计算 $e^{\eta \ln \xi}$ 。

`BallFloat::rootn` 与 `BallFloat::try_rootn`

rootn(x, n) 返回实 $n$ 次方根 $\{\xi^{1/n}\}$ 的包络： $n$ 为偶数时在 $\xi \ge 0$ 上， $n$ 为奇数时在全体实数上， $n$ 为负时取方根的倒数。

pub fn BallFloat::rootn(Self, Int) -> Self
pub fn BallFloat::try_rootn(Self, Int) -> Result[Self, @arithmetic.ArithmeticError]

rootn(x, 0) 和 rootn(x, Int min) 为 Empty；try_rootn(x, 0) 为定义域错误。rootn(x, 1) 即 x，rootn(x, 2) 即 sqrt_interval。全函数形式通过 pow_interval 并结合 $1/n$ 的包络来计算其他次数，因此可能比 try_rootn 稍宽。当 $n$ 为负且奇次方根的参数包含 0 时，try_rootn 返回 Entire。

`BallFloat::hypot` 与 `BallFloat::try_hypot`

hypot 返回 $\{\sqrt{\xi^2 + \eta^2}\}$ 的包络。

pub fn BallFloat::hypot(Self, Self) -> Self
pub fn BallFloat::try_hypot(Self, Self) -> Result[Self, @arithmetic.ArithmeticError]

该函数关于 $|\xi|$ 和 $|\eta|$ 递增，因此结果在 abs(x) 与 abs(y) 的端点处求值。全函数形式回退为 sqrt_interval(square(x) + square(y))。

三角函数

sin_interval、cos_interval 和 tan_interval 返回 $\sin$ 、 $\cos$ 和 $\tan$ 在区间上（以弧度计）的包络。

pub fn BallFloat::sin_interval(Self) -> Self
pub fn BallFloat::cos_interval(Self) -> Self
pub fn BallFloat::tan_interval(Self) -> Self
pub fn BallFloat::try_sin_interval(Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_cos_interval(Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_tan_interval(Self) -> Result[Self, @arithmetic.ArithmeticError]

两种形式都用 $\pi/2$ 的认证包络对每个端点进行约简，并计算认证 Taylor 级数。区间内的临界点 $k\pi/2$ 贡献 sin/cos 的极值 $\pm 1$ ；对于 tan，区间内若有 $\pi/2$ 的奇数倍（极点），结果为 Entire。无界参数给出 $[-1, 1]$ （对 tan 为 Entire）。当较大端点的绝对值至少为 $2^{\max(65536,\, 4p) + 1}$ 时，全函数形式不经求值直接返回 $[-1, 1]$ （Entire），try_ 形式返回资源限制错误；当 12 步细化耗尽时，全函数形式也使用同样的回退。

$\pi x$ 的三角函数

sinpi_interval、cospi_interval 和 tanpi_interval 返回 $\sin \pi\xi$ 、 $\cos \pi\xi$ 和 $\tan \pi\xi$ 的包络。

pub fn BallFloat::sinpi_interval(Self) -> Self
pub fn BallFloat::cospi_interval(Self) -> Self
pub fn BallFloat::tanpi_interval(Self) -> Self
pub fn BallFloat::try_sinpi_interval(Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_cospi_interval(Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_tanpi_interval(Self) -> Result[Self, @arithmetic.ArithmeticError]

此处临界点是精确的半整数 $k/2$ ，无需近似 $\pi$ 即可定位。当极点恰好是端点时，tanpi_interval 返回半无界区间（例如 $[1/2, 1]$ 给出 $(-\infty, 0]$ ）；对极点的单点集返回 Empty；当极点位于区间内部时返回 Entire。无界参数和回退给出 $[-1, 1]$ （对 tanpi 为 Entire）。

///|
test "trigonometric functions" {
  inspect(fmt(iv(0, 4).sin_interval()), content="[-7.56803e-1, 1.00000e+0]")
  inspect(fmt(iv(0, 4).cos_interval()), content="[-1.00000e+0, 1.00000e+0]")
  inspect(iv(1, 2).tan_interval().is_entire(), content="true")
  let half = @bin_float.BinFloat::make(@bin_float.BinCoeff::one(), -1, 53)
  let x = @ball_float.BallFloat::from_bounds(half, @bin_float.BinFloat::one(precision=53))
  inspect(fmt(x.sinpi_interval()), content="[0.00000e+0, 1.00000e+0]")
  inspect(fmt(x.tanpi_interval()), content="[-inf, 0.00000e+0]")
}

反三角函数

asin_interval、acos_interval 和 atan_interval 返回 $\arcsin$ 、 $\arccos$ （在 $[-1, 1]$ 上）和 $\arctan$ 的包络。

pub fn BallFloat::asin_interval(Self) -> Self
pub fn BallFloat::acos_interval(Self) -> Self
pub fn BallFloat::atan_interval(Self) -> Self
pub fn BallFloat::try_asin_interval(Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_acos_interval(Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_atan_interval(Self) -> Result[Self, @arithmetic.ArithmeticError]

asin 和 atan 递增，acos 递减，因此只需对端点求值。全函数形式的 atan_interval 使用认证级数，并以 Machin 公式得到 $\pi$ 的包络；asin 按 $\arctan(\xi/\sqrt{1 - \xi^2})$ 计算，acos 按 $\pi/2 - \arcsin \xi$ 计算，均多用 64 位精度。无穷端点的 atan 为 $\pm\pi/2$ 。

`BallFloat::atan2_interval` 与 `BallFloat::try_atan2_interval`

y.atan2_interval(x) 返回矩形 $\boldsymbol{x} \times \boldsymbol{y}$ 中各点 $(\xi, \eta) \ne (0, 0)$ 的辐角 $\operatorname{atan2}(\eta, \xi) \in (-\pi, \pi]$ 的包络。

pub fn BallFloat::atan2_interval(Self, Self) -> Self
pub fn BallFloat::try_atan2_interval(Self, Self) -> Result[Self, @arithmetic.ArithmeticError]

接收者是纵坐标。结果是四个角点以及矩形与坐标轴交点处的辐角的包。当矩形跨越分支切割线（ $\xi$ 为负，且 $\eta$ 取遍负值和 0）时，结果为 $[-\pi, \pi]$ 。矩形 $\{(0, 0)\}$ 给出 Empty。全函数形式回退为 $[-\pi, \pi]$ 。

双曲函数

sinh_interval、cosh_interval、tanh_interval、asinh_interval、acosh_interval 和 atanh_interval 在各自定义域上（acosh 为 $[1, \infty)$ ，atanh 为 $(-1, 1)$ ）返回双曲函数及其反函数的包络。

pub fn BallFloat::sinh_interval(Self) -> Self
pub fn BallFloat::cosh_interval(Self) -> Self
pub fn BallFloat::tanh_interval(Self) -> Self
pub fn BallFloat::asinh_interval(Self) -> Self
pub fn BallFloat::acosh_interval(Self) -> Self
pub fn BallFloat::atanh_interval(Self) -> Self
pub fn BallFloat::try_sinh_interval(Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_cosh_interval(Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_tanh_interval(Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_asinh_interval(Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_acosh_interval(Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_atanh_interval(Self) -> Result[Self, @arithmetic.ArithmeticError]

cosh 在 0 处取最小值 1；其余函数都是单调的。全函数形式在每个端点处以多 192 位的精度用区间算术计算定义公式（ $(e^\xi - e^{-\xi})/2$ 、 $\ln(\xi + \sqrt{\xi^2 + 1})$ 、 $\tfrac12 \ln\frac{1+\xi}{1-\xi}$ 等），因此从不失败；tanh_interval 被截断到 $[-1, 1]$ 。若区间到达 $\pm 1$ ，其 atanh 在该侧无界。

///|
test "inverse and hyperbolic functions" {
  let unit = iv(-1, 1)
  inspect(fmt(unit.asin_interval()), content="[-1.57080e+0, 1.57080e+0]")
  inspect(fmt(iv(-2, 2).acos_interval()), content="[0.00000e+0, 3.14160e+0]")
  inspect(fmt(iv(1, 1).atan2_interval(iv(1, 1))), content="[7.85398e-1, 7.85399e-1]")
  inspect(fmt(unit.cosh_interval()), content="[1.00000e+0, 1.54309e+0]")
  inspect(fmt(unit.atanh_interval()), content="[-inf, inf]")
}

上下文与标志

`BallContext::new` 与 `BallContext::try_new`

BallContext::new 由精度和指数范围构建上下文。

pub fn BallContext::new(precision? : Int, e_min? : Int, e_max? : Int) -> Self
pub fn BallContext::try_new(precision? : Int, e_min? : Int, e_max? : Int) -> Result[Self, @arithmetic.ArithmeticError]

默认值为 binary64 的参数：精度 53， $e_{\min} = -1022$ ， $e_{\max} = 1023$ 。精度小于 1 或 $e_{\min} > e_{\max}$ 会使 new 中止，对 try_new 则是定义域错误。

`BallContext::binary32` 与 `BallContext::binary64`

它们返回 IEEE 754 binary32（ $p = 24$ ， $[-126, 127]$ ）与 binary64（ $p = 53$ ， $[-1022, 1023]$ ）格式的上下文。

pub fn BallContext::binary32() -> Self
pub fn BallContext::binary64() -> Self

`BallContext::precision`, `BallContext::e_min`, `BallContext::e_max`

它们返回上下文的参数。

pub fn BallContext::precision(Self) -> Int
pub fn BallContext::e_min(Self) -> Int
pub fn BallContext::e_max(Self) -> Int

`BallFlags::new`、`BallFlags::combine` 及访问器

BallFlags::new 返回未触发任何条件的标志；combine 求二者的并；访问器读取各字段。

pub fn BallFlags::new() -> Self
pub fn BallFlags::combine(Self, Self) -> Self
pub fn BallFlags::inexact(Self) -> Bool
pub fn BallFlags::overflow(Self) -> Bool
pub fn BallFlags::underflow(Self) -> Bool

`BallFloat::apply_ctx`

apply_ctx 将区间向外舍入到上下文中并报告标志。

pub fn BallFloat::apply_ctx(Self, BallContext) -> (Self, BallFlags)

每个有限非零端点都向外舍入到上下文精度。舍入后指数超过 $e_{\max}$ 的端点发生上溢：若它是负的下端点或正的上端点，则变为 $\mp\infty$ ；否则变为相应符号的最大有限值（正的下端点变为最大有限值，仍低于原值）。低于正规范围的端点在次正规网格 $2^{e_{\min} - p + 1}\mathbb{Z}$ 上向外舍入，因此极小的正上端点会变为最小次正规数而不是 0。零和无穷保持不变。Empty 给出 Empty 且不设任何标志。结果具有上下文精度。

`BallFloat::add_ctx`, `BallFloat::sub_ctx`, `BallFloat::mul_ctx`, `BallFloat::div_ctx`

它们先计算运算，再应用上下文。

pub fn BallFloat::add_ctx(Self, Self, BallContext) -> (Self, BallFlags)
pub fn BallFloat::sub_ctx(Self, Self, BallContext) -> (Self, BallFlags)
pub fn BallFloat::mul_ctx(Self, Self, BallContext) -> (Self, BallFlags)
pub fn BallFloat::div_ctx(Self, Self, BallContext) -> (Self, BallFlags)

x.add_ctx(y, ctx) 即 (x + y).apply_ctx(ctx)。当操作数的精度不低于上下文精度时，这种两次舍入得到的端点与一次向外舍入到上下文所得的端点相同（参见设计文档）。

`BallFloat::exp_ctx` 与 `BallFloat::ln_ctx`

exp_ctx 和 ln_ctx 以比上下文精度多 32 位的精度计算 exp_interval 和 ln_interval，然后应用上下文。

pub fn BallFloat::exp_ctx(Self, BallContext) -> (Self, BallFlags)
pub fn BallFloat::ln_ctx(Self, BallContext) -> (Self, BallFlags)

`BallFloat::midpoint_ctx`

midpoint_ctx 返回以上下文精度就近舍入后的中心。

pub fn BallFloat::midpoint_ctx(Self, BallContext) -> (@bin_float.BinFloat, BallFlags)

次正规结果在次正规网格上舍入，不精确时触发 underflow；中心发生改变时设置 inexact。指数上限不被施加，因此从不触发 overflow。Entire 给出 0；Empty 和半无界区间会中止。

///|
test "contexts" {
  let ctx = @ball_float.BallContext::new(precision=8, e_min=-10, e_max=10)
  let (third, flags) = iv(1, 1).div_ctx(iv(3, 3), ctx)
  inspect(third.lower_bound().to_string(), content="85p-8")
  inspect(third.upper_bound().to_string(), content="171p-9")
  inspect(flags.inexact(), content="true")
  let (big, big_flags) = iv(5000, 5000).apply_ctx(ctx)
  inspect(fmt(big), content="[2.04000e+3, inf]")
  inspect(big_flags.overflow(), content="true")
  let merged = flags.combine(big_flags)
  inspect(merged.overflow() && merged.inexact(), content="true")
}

装饰区间

装饰运算计算裸结果以及装饰 $d = \min(d_1, \dots, d_k, d_f)$ ，其中 $d_i$ 是操作数的装饰， $d_f$ 是该运算在这些操作数上的装饰（当函数在整个输入矩形上有定义且连续时为 Com，当输入超出定义域时为 Trv，如下文所列）。随后将该最小值规范化（Empty → Trv，无界且为 Com → Dac）。任何 NaI 操作数都给出 NaI。

`BallFloatDecorated::new`

BallFloatDecorated::new 为裸区间添加装饰。

pub fn BallFloatDecorated::new(BallFloat, decoration? : Decoration) -> Self

默认装饰为 Com。装饰会被规范化，且 Ill 会被替换为 Trv：new 从不构建 NaI。

`BallFloatDecorated::nai` 与 `BallFloatDecorated::is_nai`

nai 返回 NaI，即无效装饰构造的结果；is_nai 检测它。

pub fn BallFloatDecorated::nai(precision? : Int) -> Self
pub fn BallFloatDecorated::is_nai(Self) -> Bool

NaI 的装饰为 Ill，区间为 Empty（默认精度 53），但它不是 Empty：对 NaI，is_empty 为假。

`BallFloatDecorated::interval` 与 `BallFloatDecorated::decoration`

它们返回裸区间和装饰。

pub fn BallFloatDecorated::interval(Self) -> BallFloat
pub fn BallFloatDecorated::decoration(Self) -> Decoration

装饰谓词与关系

BallFloatDecorated 的谓词和关系将相应的裸关系作用于区间，当有操作数为 NaI 时返回假。

pub fn BallFloatDecorated::is_empty(Self) -> Bool
pub fn BallFloatDecorated::is_entire(Self) -> Bool
pub fn BallFloatDecorated::is_common_interval(Self) -> Bool
pub fn BallFloatDecorated::is_singleton(Self) -> Bool
pub fn BallFloatDecorated::contains(Self, @bin_float.BinFloat) -> Bool
pub fn BallFloatDecorated::set_equal(Self, Self) -> Bool
pub fn BallFloatDecorated::subset(Self, Self) -> Bool
pub fn BallFloatDecorated::interior(Self, Self) -> Bool
pub fn BallFloatDecorated::disjoint(Self, Self) -> Bool
pub fn BallFloatDecorated::less(Self, Self) -> Bool
pub fn BallFloatDecorated::strictly_less(Self, Self) -> Bool
pub fn BallFloatDecorated::precedes(Self, Self) -> Bool
pub fn BallFloatDecorated::strictly_precedes(Self, Self) -> Bool
pub fn BallFloatDecorated::overlap_state(Self, Self) -> OverlapState

当有操作数为 NaI 时，overlap_state 返回 Undefined。

装饰集合运算

intersection、convex_hull、cancel_plus 和 cancel_minus 应用裸运算，并总是将装饰降为 Trv（集合运算不是逐点函数）。

pub fn BallFloatDecorated::intersection(Self, Self) -> Self
pub fn BallFloatDecorated::convex_hull(Self, Self) -> Self
pub fn BallFloatDecorated::cancel_plus(Self, Self) -> Self
pub fn BallFloatDecorated::cancel_minus(Self, Self) -> Self

装饰算术

算术运算应用裸运算；除表中另有说明外，其运算装饰为 Com。

pub fn BallFloatDecorated::add(Self, Self) -> Self
pub fn BallFloatDecorated::sub(Self, Self) -> Self
pub fn BallFloatDecorated::mul(Self, Self) -> Self
pub fn BallFloatDecorated::div(Self, Self) -> Self
pub fn BallFloatDecorated::pos(Self) -> Self
pub fn BallFloatDecorated::neg(Self) -> Self
pub fn BallFloatDecorated::abs(Self) -> Self
pub fn BallFloatDecorated::reciprocal(Self) -> Self
pub fn BallFloatDecorated::square(Self) -> Self
pub fn BallFloatDecorated::pown(Self, Int) -> Self
pub fn BallFloatDecorated::fma(Self, Self, Self) -> Self
pub fn BallFloatDecorated::minimum(Self, Self) -> Self
pub fn BallFloatDecorated::maximum(Self, Self) -> Self

操作	运算装饰
`div`, `reciprocal`	除数包含 0 时为 `Trv`
`pown(x, n)`	当 $n < 0$ 且 $0 \in \boldsymbol{x}$ 时为 `Trv`
`pos`	恒等（IEEE 1788 `pos`）
其他	`Com`

装饰初等函数

装饰初等函数应用裸的全函数形式（没有装饰版的 try_ 形式），并在输入超出函数定义域时降低装饰。

pub fn BallFloatDecorated::sqrt_interval(Self) -> Self
pub fn BallFloatDecorated::exp_interval(Self) -> Self
pub fn BallFloatDecorated::exp2_interval(Self) -> Self
pub fn BallFloatDecorated::exp10_interval(Self) -> Self
pub fn BallFloatDecorated::expm1_interval(Self) -> Self
pub fn BallFloatDecorated::ln_interval(Self) -> Self
pub fn BallFloatDecorated::log2_interval(Self) -> Self
pub fn BallFloatDecorated::log10_interval(Self) -> Self
pub fn BallFloatDecorated::log1p_interval(Self) -> Self
pub fn BallFloatDecorated::pow_interval(Self, Self) -> Self
pub fn BallFloatDecorated::rootn(Self, Int) -> Self
pub fn BallFloatDecorated::hypot(Self, Self) -> Self
pub fn BallFloatDecorated::sin_interval(Self) -> Self
pub fn BallFloatDecorated::cos_interval(Self) -> Self
pub fn BallFloatDecorated::tan_interval(Self) -> Self
pub fn BallFloatDecorated::sinpi_interval(Self) -> Self
pub fn BallFloatDecorated::cospi_interval(Self) -> Self
pub fn BallFloatDecorated::tanpi_interval(Self) -> Self
pub fn BallFloatDecorated::asin_interval(Self) -> Self
pub fn BallFloatDecorated::acos_interval(Self) -> Self
pub fn BallFloatDecorated::atan_interval(Self) -> Self
pub fn BallFloatDecorated::atan2_interval(Self, Self) -> Self
pub fn BallFloatDecorated::sinh_interval(Self) -> Self
pub fn BallFloatDecorated::cosh_interval(Self) -> Self
pub fn BallFloatDecorated::tanh_interval(Self) -> Self
pub fn BallFloatDecorated::asinh_interval(Self) -> Self
pub fn BallFloatDecorated::acosh_interval(Self) -> Self
pub fn BallFloatDecorated::atanh_interval(Self) -> Self

函数	运算装饰为 `Trv` 的条件
`sqrt_interval`	$\underline{x} < 0$ （或输入为 Empty）
`ln_interval`, `log2_interval`, `log10_interval`	$\underline{x} \le 0$
`log1p_interval`	$\underline{x} \le -1$
`asin_interval`, `acos_interval`	$\boldsymbol{x} \not\subseteq [-1, 1]$
`acosh_interval`	$\underline{x} < 1$
`atanh_interval`	$\underline{x} \le -1$ 或 $\overline{x} \ge 1$
`rootn(x, n)`	$n = 0$ ，或 $n$ 为偶数且 $\underline{x} < 0$
`pow_interval(x, y)`	$\underline{x} < 0$ ，或 $0 \in \boldsymbol{x}$ 且 $\underline{y} \le 0$ ，或结果为 Empty
`tan_interval`, `tanpi_interval`	结果为 Entire（内部可能有极点）
`atan2_interval`	两个操作数都包含 0

其他所有函数的运算装饰均为 Com。对于 y.atan2_interval(x)，当矩形跨越分支切割线（ $\underline{x} < 0$ ， $\underline{y} < 0 \le \overline{y}$ ）时装饰为 Def，当它从上方触及切割线（ $\overline{x} < 0$ ， $\underline{y} = 0$ ）时装饰为 Dac。

`BallFloatDecorated::apply_ctx`

apply_ctx 将 BallFloat::apply_ctx 应用于区间并保留装饰（会再次规范化，因此发生上溢的 Com 变为 Dac）。

pub fn BallFloatDecorated::apply_ctx(Self, BallContext) -> (Self, BallFlags)

NaI 仍为 NaI，并带上上下文精度。

///|
test "decorated intervals" {
  let x = @ball_float.BallFloatDecorated::new(iv(-1, 4))
  inspect(x.sqrt_interval().decoration(), content="trv")
  inspect(x.exp_interval().decoration(), content="com")
  inspect((x / x).decoration(), content="trv")
  let unbounded = @ball_float.BallFloatDecorated::new(@ball_float.BallFloat::whole())
  inspect(unbounded.decoration(), content="dac")
  let nai = @ball_float.BallFloatDecorated::nai()
  inspect((x + nai).to_string(), content="[nai]")
  debug_inspect(nai.overlap_state(x), content="Undefined")
}

trait 实现

运算符

BallFloat 实现了 Add、Sub、Mul、Div 和 Neg；BallFloatDecorated 实现了 Add、Sub、Mul 和 Div。这些运算符调用同名方法。

pub impl Add for BallFloat
pub impl Sub for BallFloat
pub impl Mul for BallFloat
pub impl Div for BallFloat
pub impl Neg for BallFloat
pub impl Add for BallFloatDecorated
pub impl Sub for BallFloatDecorated
pub impl Mul for BallFloatDecorated
pub impl Div for BallFloatDecorated

`Show`

Show 以精确的文本形式输出区间。

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

有界的 BallFloat 输出为 center +/- radius，两个数都使用精确的 BinFloat 记法（3p-1 表示 $3 \cdot 2^{-1}$ ），因此文本恰好表示所存储的集合；无界的输出为 [lo, hi]，Empty 输出为 [empty]。装饰区间会附加 _ 及装饰；NaI 输出为 [nai]。

///|
test "show" {
  inspect(iv(1, 2).to_string(), content="3p-1 +/- 1p-1")
  inspect(@ball_float.BallFloat::whole().to_string(), content="[-inf, inf]")
  inspect(@ball_float.BallFloatDecorated::new(iv(1, 2)).to_string(), content="3p-1 +/- 1p-1_com")
}

`Eq` 与 `Debug`

pub fn BallFloat::equal(Self, Self) -> Bool
pub fn BallFloat::not_equal(Self, Self) -> Bool
pub fn BallFloat::to_repr(Self) -> @debug.Repr
pub fn BallFloatDecorated::equal(Self, Self) -> Bool
pub fn BallFloatDecorated::not_equal(Self, Self) -> Bool
pub fn BallFlags::equal(Self, Self) -> Bool
pub fn BallFlags::not_equal(Self, Self) -> Bool
pub fn Decoration::equal(Self, Self) -> Bool
pub fn Decoration::not_equal(Self, Self) -> Bool
pub fn Decoration::to_repr(Self) -> @debug.Repr
pub fn OverlapState::equal(Self, Self) -> Bool
pub fn OverlapState::not_equal(Self, Self) -> Bool
pub fn OverlapState::to_repr(Self) -> @debug.Repr

Eq 的实现是派生的，比较的是表示。对于 BallFloat 和 BallFloatDecorated，这会区分以不同精度标记或端点精度存储的相等集合；比较集合请使用 set_equal。to_repr 给出结构化的 Debug 形式。

`@def.Floating`

BallFloat 实现了 def 的 Floating trait，其中 classify、sign、precision、with_precision 和 normalized 如上文所述，因此通用谓词 @def.is_finite（有界）、@def.is_infinite（无界）、@def.is_nan（Empty）和 @def.is_zero（符号为 Zero，即包含 0）也适用于区间。

pub impl @def.Floating for BallFloat

`arithmetic` 的包络关系

BallFloat 实现了 Luna-Flow/arithmetic 的包络关系 trait。

pub impl @arithmetic.Contains for BallFloat
pub impl @arithmetic.Overlaps for BallFloat
pub impl @arithmetic.DefinitelyLt for BallFloat
pub impl @arithmetic.DefinitelyLe for BallFloat
pub impl @arithmetic.MaybeEq for BallFloat

Contains::contains(x, y) 即 y.subset(x)（集合包含，而不是接受点的那个方法）；其他方法调用同名方法。

`arithmetic` 的 checked 能力

BallFloat 实现了 DivChecked、PowNatChecked 和 PowIntChecked；它们的方法被提升为该类型的方法。

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

只使用 ctx.precision：操作数先用 with_precision 重新舍入到该精度，再应用运算，然后重新舍入结果。它们总是返回 Ok。div_checked 遵循上述除法规则（除数包含 0 时给出无界结果，而不是错误）。pow_int_checked 使用 pown。pow_nat_checked 通过重复的区间乘法进行二进制求幂，这会把各因子视为相互独立：对于包含 0 的参数，其结果比 pown 更宽。

///|
test "checked capabilities" {
  let ctx = @lf_arith.ArithmeticContext::new(53)
  let x = iv(-1, 2)
  inspect(fmt(x.pow_int_checked(2, ctx).unwrap()), content="[0.00000e+0, 4.00000e+0]")
  inspect(fmt(x.pow_nat_checked(2U, ctx).unwrap()), content="[-2.00000e+0, 4.00000e+0]")
  inspect(x.div_checked(iv(-1, 1), ctx).unwrap().is_entire(), content="true")
  inspect(@lf_arith.Contains::contains(iv(0, 9), iv(1, 2)), content="true")
}

完整公共接口

此快照是该包生成的 pkg.generated.mbti。当正文与接口不一致时，以接口为准。

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

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

// Values

// Errors

// Types and methods
pub struct BallContext {
  // private fields
}
pub fn BallContext::binary32() -> Self
pub fn BallContext::binary64() -> Self
pub fn BallContext::e_max(Self) -> Int
pub fn BallContext::e_min(Self) -> Int
pub fn BallContext::new(precision? : Int, e_min? : Int, e_max? : Int) -> Self
pub fn BallContext::precision(Self) -> Int
pub fn BallContext::try_new(precision? : Int, e_min? : Int, e_max? : Int) -> Result[Self, @arithmetic.ArithmeticError]

pub struct BallFlags {
  inexact : Bool
  overflow : Bool
  underflow : Bool
} derive(Eq)
pub fn BallFlags::combine(Self, Self) -> Self
pub fn BallFlags::equal(Self, Self) -> Bool
pub fn BallFlags::inexact(Self) -> Bool
pub fn BallFlags::new() -> Self
pub fn BallFlags::not_equal(Self, Self) -> Bool
pub fn BallFlags::overflow(Self) -> Bool
pub fn BallFlags::underflow(Self) -> Bool

pub struct BallFloat {
  // private fields
} derive(Eq, @debug.Debug)
pub fn BallFloat::abs(Self) -> Self
pub fn BallFloat::acos_interval(Self) -> Self
pub fn BallFloat::acosh_interval(Self) -> Self
pub fn BallFloat::add(Self, Self) -> Self
pub fn BallFloat::add_ctx(Self, Self, BallContext) -> (Self, BallFlags)
pub fn BallFloat::apply_ctx(Self, BallContext) -> (Self, BallFlags)
pub fn BallFloat::asin_interval(Self) -> Self
pub fn BallFloat::asinh_interval(Self) -> Self
pub fn BallFloat::atan2_interval(Self, Self) -> Self
pub fn BallFloat::atan_interval(Self) -> Self
pub fn BallFloat::atanh_interval(Self) -> Self
pub fn BallFloat::cancel_minus(Self, Self) -> Self
pub fn BallFloat::cancel_plus(Self, Self) -> Self
pub fn BallFloat::center(Self) -> @bin_float.BinFloat
pub fn BallFloat::classify(Self) -> @arithmetic.FpClass
pub fn BallFloat::contains(Self, @bin_float.BinFloat) -> Bool
pub fn BallFloat::contains_zero(Self) -> Bool
pub fn BallFloat::convex_hull(Self, Self) -> Self
pub fn BallFloat::cos_interval(Self) -> Self
pub fn BallFloat::cosh_interval(Self) -> Self
pub fn BallFloat::cospi_interval(Self) -> Self
pub fn BallFloat::definitely_gt(Self, Self) -> Bool
pub fn BallFloat::definitely_le(Self, Self) -> Bool
pub fn BallFloat::definitely_lt(Self, Self) -> Bool
pub fn BallFloat::disjoint(Self, Self) -> Bool
pub fn BallFloat::div(Self, Self) -> Self
pub fn BallFloat::div_checked(Self, Self, @arithmetic.ArithmeticContext) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::div_ctx(Self, Self, BallContext) -> (Self, BallFlags)
pub fn BallFloat::empty(precision? : Int) -> Self
pub fn BallFloat::equal(Self, Self) -> Bool
pub fn BallFloat::exact(@bin_float.BinFloat, precision? : Int) -> Self
pub fn BallFloat::exp10_interval(Self) -> Self
pub fn BallFloat::exp2_interval(Self) -> Self
pub fn BallFloat::exp_ctx(Self, BallContext) -> (Self, BallFlags)
pub fn BallFloat::exp_interval(Self) -> Self
pub fn BallFloat::expm1_interval(Self) -> Self
pub fn BallFloat::fma(Self, Self, Self) -> Self
pub fn BallFloat::from_bounds(@bin_float.BinFloat, @bin_float.BinFloat, precision? : Int) -> Self
pub fn BallFloat::from_coefficient(@bin_float.BinCoeff, precision? : Int, negative? : Bool) -> Self
pub fn BallFloat::from_double(Double, precision? : Int) -> Self
pub fn BallFloat::from_float(Float, precision? : Int) -> Self
pub fn BallFloat::from_int(Int, precision? : Int) -> Self
pub fn BallFloat::hypot(Self, Self) -> Self
pub fn BallFloat::interior(Self, Self) -> Bool
pub fn BallFloat::intersection(Self, Self) -> Self
pub fn BallFloat::is_bounded(Self) -> Bool
pub fn BallFloat::is_common_interval(Self) -> Bool
pub fn BallFloat::is_empty(Self) -> Bool
pub fn BallFloat::is_entire(Self) -> Bool
pub fn BallFloat::is_singleton(Self) -> Bool
pub fn BallFloat::less(Self, Self) -> Bool
pub fn BallFloat::ln_ctx(Self, BallContext) -> (Self, BallFlags)
pub fn BallFloat::ln_interval(Self) -> Self
pub fn BallFloat::log10_interval(Self) -> Self
pub fn BallFloat::log1p_interval(Self) -> Self
pub fn BallFloat::log2_interval(Self) -> Self
pub fn BallFloat::lower_bound(Self) -> @bin_float.BinFloat
pub fn BallFloat::magnitude(Self) -> @bin_float.BinFloat
pub fn BallFloat::maximum(Self, Self) -> Self
pub fn BallFloat::maybe_eq(Self, Self) -> Bool
pub fn BallFloat::midpoint(Self) -> @bin_float.BinFloat
pub fn BallFloat::midpoint_ctx(Self, BallContext) -> (@bin_float.BinFloat, BallFlags)
pub fn BallFloat::mignitude(Self) -> @bin_float.BinFloat
pub fn BallFloat::minimum(Self, Self) -> Self
pub fn BallFloat::mul(Self, Self) -> Self
pub fn BallFloat::mul_ctx(Self, Self, BallContext) -> (Self, BallFlags)
pub fn BallFloat::neg(Self) -> Self
pub fn BallFloat::new(@bin_float.BinFloat, @bin_float.BinFloat, precision? : Int) -> Self
pub fn BallFloat::normalized(Self) -> Self
pub fn BallFloat::not_equal(Self, Self) -> Bool
pub fn BallFloat::output(Self, &Logger) -> Unit
pub fn BallFloat::overlap_state(Self, Self) -> OverlapState
pub fn BallFloat::overlaps(Self, Self) -> Bool
pub fn BallFloat::pow_int_checked(Self, Int, @arithmetic.ArithmeticContext) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::pow_interval(Self, Self) -> Self
pub fn BallFloat::pow_nat_checked(Self, UInt, @arithmetic.ArithmeticContext) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::pown(Self, Int) -> Self
pub fn BallFloat::precedes(Self, Self) -> Bool
pub fn BallFloat::precision(Self) -> Int
pub fn BallFloat::radius(Self) -> @bin_float.BinFloat
pub fn BallFloat::radius_extended(Self) -> @bin_float.BinFloat
pub fn BallFloat::reciprocal(Self) -> Self
pub fn BallFloat::rootn(Self, Int) -> Self
pub fn BallFloat::separated_from(Self, Self) -> Bool
pub fn BallFloat::set_equal(Self, Self) -> Bool
pub fn BallFloat::sign(Self) -> @def.Sign
pub fn BallFloat::sin_interval(Self) -> Self
pub fn BallFloat::sinh_interval(Self) -> Self
pub fn BallFloat::sinpi_interval(Self) -> Self
pub fn BallFloat::sqrt_interval(Self) -> Self
pub fn BallFloat::square(Self) -> Self
pub fn BallFloat::strictly_less(Self, Self) -> Bool
pub fn BallFloat::strictly_precedes(Self, Self) -> Bool
pub fn BallFloat::sub(Self, Self) -> Self
pub fn BallFloat::sub_ctx(Self, Self, BallContext) -> (Self, BallFlags)
pub fn BallFloat::subset(Self, Self) -> Bool
pub fn BallFloat::tan_interval(Self) -> Self
pub fn BallFloat::tanh_interval(Self) -> Self
pub fn BallFloat::tanpi_interval(Self) -> Self
pub fn BallFloat::to_repr(Self) -> @debug.Repr
pub fn BallFloat::to_string(Self) -> String
pub fn BallFloat::try_acos_interval(Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_acosh_interval(Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_asin_interval(Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_asinh_interval(Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_atan2_interval(Self, Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_atan_interval(Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_atanh_interval(Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_cos_interval(Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_cosh_interval(Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_cospi_interval(Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_exact(@bin_float.BinFloat, precision? : Int) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_exp10_interval(Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_exp2_interval(Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_exp_interval(Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_expm1_interval(Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_from_bounds(@bin_float.BinFloat, @bin_float.BinFloat, precision? : Int) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_from_double(Double, precision? : Int) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_from_float(Float, precision? : Int) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_hypot(Self, Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_ln_interval(Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_log10_interval(Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_log1p_interval(Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_log2_interval(Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_pow_interval(Self, Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_rootn(Self, Int) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_sin_interval(Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_sinh_interval(Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_sinpi_interval(Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_tan_interval(Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_tanh_interval(Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::try_tanpi_interval(Self) -> Result[Self, @arithmetic.ArithmeticError]
pub fn BallFloat::upper_bound(Self) -> @bin_float.BinFloat
pub fn BallFloat::whole(precision? : Int) -> Self
pub fn BallFloat::width(Self) -> @bin_float.BinFloat
pub fn BallFloat::with_precision(Self, Int, @arithmetic.RoundingMode) -> Self
pub impl @arithmetic.Contains for BallFloat
pub impl @arithmetic.DefinitelyLe for BallFloat
pub impl @arithmetic.DefinitelyLt for BallFloat
pub impl @arithmetic.DivChecked for BallFloat
pub impl @arithmetic.MaybeEq for BallFloat
pub impl @arithmetic.Overlaps for BallFloat
pub impl @arithmetic.PowIntChecked for BallFloat
pub impl @arithmetic.PowNatChecked for BallFloat
pub impl @def.Floating for BallFloat
pub impl Add for BallFloat
pub impl Div for BallFloat
pub impl Mul for BallFloat
pub impl Neg for BallFloat
pub impl Show for BallFloat
pub impl Sub for BallFloat

pub struct BallFloatDecorated {
  // private fields
} derive(Eq)
pub fn BallFloatDecorated::abs(Self) -> Self
pub fn BallFloatDecorated::acos_interval(Self) -> Self
pub fn BallFloatDecorated::acosh_interval(Self) -> Self
pub fn BallFloatDecorated::add(Self, Self) -> Self
pub fn BallFloatDecorated::apply_ctx(Self, BallContext) -> (Self, BallFlags)
pub fn BallFloatDecorated::asin_interval(Self) -> Self
pub fn BallFloatDecorated::asinh_interval(Self) -> Self
pub fn BallFloatDecorated::atan2_interval(Self, Self) -> Self
pub fn BallFloatDecorated::atan_interval(Self) -> Self
pub fn BallFloatDecorated::atanh_interval(Self) -> Self
pub fn BallFloatDecorated::cancel_minus(Self, Self) -> Self
pub fn BallFloatDecorated::cancel_plus(Self, Self) -> Self
pub fn BallFloatDecorated::contains(Self, @bin_float.BinFloat) -> Bool
pub fn BallFloatDecorated::convex_hull(Self, Self) -> Self
pub fn BallFloatDecorated::cos_interval(Self) -> Self
pub fn BallFloatDecorated::cosh_interval(Self) -> Self
pub fn BallFloatDecorated::cospi_interval(Self) -> Self
pub fn BallFloatDecorated::decoration(Self) -> Decoration
pub fn BallFloatDecorated::disjoint(Self, Self) -> Bool
pub fn BallFloatDecorated::div(Self, Self) -> Self
pub fn BallFloatDecorated::equal(Self, Self) -> Bool
pub fn BallFloatDecorated::exp10_interval(Self) -> Self
pub fn BallFloatDecorated::exp2_interval(Self) -> Self
pub fn BallFloatDecorated::exp_interval(Self) -> Self
pub fn BallFloatDecorated::expm1_interval(Self) -> Self
pub fn BallFloatDecorated::fma(Self, Self, Self) -> Self
pub fn BallFloatDecorated::hypot(Self, Self) -> Self
pub fn BallFloatDecorated::interior(Self, Self) -> Bool
pub fn BallFloatDecorated::intersection(Self, Self) -> Self
pub fn BallFloatDecorated::interval(Self) -> BallFloat
pub fn BallFloatDecorated::is_common_interval(Self) -> Bool
pub fn BallFloatDecorated::is_empty(Self) -> Bool
pub fn BallFloatDecorated::is_entire(Self) -> Bool
pub fn BallFloatDecorated::is_nai(Self) -> Bool
pub fn BallFloatDecorated::is_singleton(Self) -> Bool
pub fn BallFloatDecorated::less(Self, Self) -> Bool
pub fn BallFloatDecorated::ln_interval(Self) -> Self
pub fn BallFloatDecorated::log10_interval(Self) -> Self
pub fn BallFloatDecorated::log1p_interval(Self) -> Self
pub fn BallFloatDecorated::log2_interval(Self) -> Self
pub fn BallFloatDecorated::maximum(Self, Self) -> Self
pub fn BallFloatDecorated::minimum(Self, Self) -> Self
pub fn BallFloatDecorated::mul(Self, Self) -> Self
pub fn BallFloatDecorated::nai(precision? : Int) -> Self
pub fn BallFloatDecorated::neg(Self) -> Self
pub fn BallFloatDecorated::new(BallFloat, decoration? : Decoration) -> Self
pub fn BallFloatDecorated::not_equal(Self, Self) -> Bool
pub fn BallFloatDecorated::output(Self, &Logger) -> Unit
pub fn BallFloatDecorated::overlap_state(Self, Self) -> OverlapState
pub fn BallFloatDecorated::pos(Self) -> Self
pub fn BallFloatDecorated::pow_interval(Self, Self) -> Self
pub fn BallFloatDecorated::pown(Self, Int) -> Self
pub fn BallFloatDecorated::precedes(Self, Self) -> Bool
pub fn BallFloatDecorated::reciprocal(Self) -> Self
pub fn BallFloatDecorated::rootn(Self, Int) -> Self
pub fn BallFloatDecorated::set_equal(Self, Self) -> Bool
pub fn BallFloatDecorated::sin_interval(Self) -> Self
pub fn BallFloatDecorated::sinh_interval(Self) -> Self
pub fn BallFloatDecorated::sinpi_interval(Self) -> Self
pub fn BallFloatDecorated::sqrt_interval(Self) -> Self
pub fn BallFloatDecorated::square(Self) -> Self
pub fn BallFloatDecorated::strictly_less(Self, Self) -> Bool
pub fn BallFloatDecorated::strictly_precedes(Self, Self) -> Bool
pub fn BallFloatDecorated::sub(Self, Self) -> Self
pub fn BallFloatDecorated::subset(Self, Self) -> Bool
pub fn BallFloatDecorated::tan_interval(Self) -> Self
pub fn BallFloatDecorated::tanh_interval(Self) -> Self
pub fn BallFloatDecorated::tanpi_interval(Self) -> Self
pub fn BallFloatDecorated::to_string(Self) -> String
pub impl Add for BallFloatDecorated
pub impl Div for BallFloatDecorated
pub impl Mul for BallFloatDecorated
pub impl Show for BallFloatDecorated
pub impl Sub for BallFloatDecorated

pub(all) enum Decoration {
  Ill
  Trv
  Def
  Dac
  Com
} derive(Eq, @debug.Debug)
pub fn Decoration::equal(Self, Self) -> Bool
pub fn Decoration::not_equal(Self, Self) -> Bool
pub fn Decoration::output(Self, &Logger) -> Unit
pub fn Decoration::to_repr(Self) -> @debug.Repr
pub fn Decoration::to_string(Self) -> String
pub impl Show for Decoration

pub(all) enum OverlapState {
  Undefined
  BothEmpty
  FirstEmpty
  SecondEmpty
  Before
  Meets
  OverlapsState
  Starts
  ContainedBy
  Finishes
  EqualIntervals
  After
  MetBy
  OverlappedBy
  StartedBy
  ContainsInterval
  FinishedBy
} derive(Eq, @debug.Debug)
pub fn OverlapState::equal(Self, Self) -> Bool
pub fn OverlapState::not_equal(Self, Self) -> Bool
pub fn OverlapState::to_repr(Self) -> @debug.Repr

// Type aliases

// Traits

ball_float API

类型

BallFloat

BallFloatDecorated

Decoration

OverlapState

BallContext

BallFlags

构造

BallFloat::new

BallFloat::from_bounds 与 BallFloat::try_from_bounds

BallFloat::exact 与 BallFloat::try_exact

BallFloat::from_int 与 BallFloat::from_coefficient

BallFloat::from_double、BallFloat::from_float 及其 try_ 形式

BallFloat::whole 与 BallFloat::empty

观察函数

BallFloat::lower_bound 与 BallFloat::upper_bound

BallFloat::center 与 BallFloat::radius

BallFloat::midpoint

BallFloat::width 与 BallFloat::radius_extended

BallFloat::magnitude 与 BallFloat::mignitude

BallFloat::precision、BallFloat::classify 与 BallFloat::sign

形状谓词

精度

BallFloat::with_precision

BallFloat::normalized

集合运算

BallFloat::intersection 与 BallFloat::convex_hull

BallFloat::cancel_plus 与 BallFloat::cancel_minus

关系

BallFloat::contains

BallFloat::subset, BallFloat::interior, BallFloat::set_equal, BallFloat::disjoint

BallFloat::overlaps, BallFloat::maybe_eq, BallFloat::separated_from

BallFloat::definitely_lt, BallFloat::definitely_le, BallFloat::definitely_gt

BallFloat::less, BallFloat::strictly_less, BallFloat::precedes, BallFloat::strictly_precedes

BallFloat::overlap_state

算术

BallFloat::add, BallFloat::sub, BallFloat::mul, BallFloat::div

BallFloat::neg 与 BallFloat::abs

BallFloat::reciprocal

BallFloat::square 与 BallFloat::pown

BallFloat::fma

BallFloat::minimum 与 BallFloat::maximum