`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 を持つことはなく、Ill を持つのは BallFloatDecorated::nai だけです。

`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 の結果であり、2 つの区間の相対位置に関する 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 に接尾辞が付いているのは、メソッド名との衝突を避けるためだけです。Undefined は、オペランドが NaI のときに装飾付き版だけが返します。

`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 は端点が変化したときに、overflow は端点が $e_{\max}$ を超えたときに、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 を囲む 2 点の区間になります。有限でない 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 での名前）は同じもので、区間が空でなく両端点が有限であることを判定します。is_singleton は $\underline{x} = \overline{x}$ のとき成り立ちます。contains_zero は Empty に対して偽です。

精度

`BallFloat::with_precision`

with_precision は、区間を縮めることなく新しい精度へ丸め直します。

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

有界な区間では、中心を mode で丸め、その変位を半径に加え、BallFloat::new と同様に結果を再構築します。非有界な区間では有限な端点を外向きに丸め、mode は無視されます。Empty は新しい精度の Empty のままです。新しい精度がおよそ $2^{16}$ ビットを超える場合の、center の項で述べた極端なケースを除き、結果は常に入力を含みます。

`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}$ と有界または空の $\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 は含みません）。トレイトメソッド @lf_arith.Contains::contains は代わりに 2 つの区間を受け取り包含関係を判定します。トレイト実装を参照してください。

`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 は 2 つの区間が共通の点を持つかを判定します。maybe_eq は同じ関係を「2 つの未知の点が等しい可能性がある」と読んだものであり、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 のとき 3 つとも偽です（空虚に真となる 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 は 2 つの区間の相対位置を分類します。

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

結果は OverlapState の 16 の状態のうち Undefined 以外のいずれかであり、4 つの端点の比較から計算されます。

///|
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 を与えます）。有界なオペランドでは、オペランドの符号によって極値となり得る 2 つの積が選ばれるため、評価される積は高々 2 つ（両オペランドが 0 を含む場合は 4 つ）です。

除算は IEEE 1788 に従います。 $\boldsymbol{x} / \boldsymbol{y}$ は $\{\xi/\eta : \eta \ne 0\}$ の凸包です。

除数 $\boldsymbol{y}$	結果
$0 \notin \boldsymbol{y}$	端点の商 $Q$ にわたる $[\operatorname{RD}\min Q, \operatorname{RU}\max 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 と異なり、これらは同じ点を 2 回用いるため、[-1, 2].square() は $[0, 4]$ になります（x * x は $[-2, 4]$ ）。pown は $\xi^n$ の単調な各部分を端点で方向付き丸めにより評価します。正の奇数乗は増加、正の偶数乗は減少してから増加し、 $0 \in \boldsymbol{x}$ のとき最小値は 0、負のべきは 0 に極を持ちます。pown(x, 0) は空でないすべての x に対して $\{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) は、1 回の外向き丸めで $\{\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 は max を用いた同様のものです。Empty のオペランドからは Empty が得られます。

初等関数

各関数 $f$ は $f(\boldsymbol{x} \cap D_f)$ を含む区間を返します。ここで $D_f$ は $f$ の定義域です。 $D_f$ の外にある $\boldsymbol{x}$ の点は無視され、 $\boldsymbol{x} \cap D_f$ が空のとき結果は Empty になります。結果の精度は引数の精度です。

関数には 2 つの形式があります。全域形式（exp_interval、sin_interval など）は常に有効な包含区間を返します。認証付き評価が精密化の予算を使い果たした場合は、より広いが依然として有効な区間を返します。try_ 形式（try_exp_interval など）はその場合 Err(ArithmeticError) を返し、演算・段階・理由を示す認証失敗の詳細を伴います。特に断りのない限り、try_ 形式は各端点を対応する bin_float の try_*_ctx 関数で $-\infty$ または $+\infty$ 方向に丸めて評価します。全域形式はそれらを呼び出すか、このパッケージの認証付き級数を用います。通常の入力では両形式は同じ集合を返しますが、上下界は 1 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]

4 つとも増加関数なので、結果は $[\operatorname{RD} f(\underline{x}), \operatorname{RU} f(\overline{x})]$ です。exp_interval は引数の半減を伴う認証付きテイラー級数を用い、フォールバックを必要としません。 $|\xi| \ge 2^{30}$ に対しては $[\text{largest finite}, +\infty)$ または $[0, \text{smallest positive}]$ を返します。exp2_interval と exp10_interval は $e^{\xi \ln b}$ を 96 ビット余分に評価し、整数の端点に対しては厳密なべきを返します（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) は、pow の IEEE 1788 定義域（ $\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 を使ってください）。結果は 4 つの角の値の凸包であり、底の区間が 1 を含むか指数の区間が 0 を含むときは 1 で、底が正の指数で 0 に達するときは 0 で、底が負の指数で 0 に達するときは $+\infty$ で拡張されます。 $\eta \le 0$ に対する $0^{\eta}$ は除外されるため、 $\overline{y} \le 0$ のとき pow_interval([0, 0], y) は Empty です。結果の精度はオペランドの精度のうち大きい方です。全域形式は、 $e^{\eta \ln \xi}$ を 192 ビット余分に評価する方法にフォールバックします。

`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 です。全域形式はその他の次数を $1/n$ の包含区間を用いた pow_interval で評価するため、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$ の認証付き包含区間で引数還元し、認証付きテイラー級数を評価します。区間内の臨界点 $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 は、 $\pi$ の Machin 公式による包含区間を用いた認証付き級数を使います。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]

レシーバは縦座標です。結果は、4 つの角と、箱が座標軸と交わる点での角度の凸包です。箱が分枝切断を横切る場合（ $\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 をとり、その他は単調です。全域形式は定義式（ $(e^\xi - e^{-\xi})/2$ 、 $\ln(\xi + \sqrt{\xi^2 + 1})$ 、 $\tfrac12 \ln\frac{1+\xi}{1-\xi}$ など）を各端点で 192 ビット余分の区間演算により評価するため、失敗することはありません。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) です。オペランドの精度がコンテキストの精度以上であれば、二重丸めはコンテキストへの 1 回の外向き丸めと同じ端点を与えます（設計ページを参照）。

`BallFloat::exp_ctx` と `BallFloat::ln_ctx`

exp_ctx と ln_ctx は、exp_interval と ln_interval をコンテキストの精度より 32 ビット多く評価してから、コンテキストを適用します。

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

overlap_state はオペランドが NaI のとき 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")
}

トレイト実装

演算子

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 トレイトを、上で説明した 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 の包含関係トレイトを実装します。

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