`bin_float_checked` API

bin_float_checked 提供 BinFloatResult，它是对 Result[BinFloat, ArithmeticError] 的封闭包装。每个运算都接受并返回 BinFloatResult：当所有操作数均为成功值时，执行相应的 bin_float 运算，否则传递第一个错误。该包装不保留任何 IEEE 标志。教程逐步构建运算流水线；设计页面将该包装建模为错误单子（error monad），并证明了它所依赖的复合律。

示例使用如下辅助函数打印结果：

///|
fn show(r : @bin_float_checked.BinFloatResult) -> String {
  match r.result() {
    Ok(v) => v.to_string()
    Err(e) => "error: " + e.message
  }
}

BinFloat::to_string 以 coefficient p exponent 的形式打印精确值，因此 3p-1 表示 $3 \cdot 2^{-1} = 1.5$ 。

包装类型

`BinFloatResult`

BinFloatResult 要么是一个成功的 BinFloat，要么是一个 ArithmeticError。

pub struct BinFloatResult {
  // private fields
}

唯一的字段是私有的，保存一个 Result[@bin_float.BinFloat, @arithmetic.ArithmeticError]。该类型没有 Eq 或 Show 实例；请通过 result() 进行比较或打印。

构造

`BinFloatResult::ok`, `BinFloatResult::err`, `BinFloatResult::from_result`

这些函数包装已有的值、错误或 Result，不做任何改变。

pub fn BinFloatResult::ok(@bin_float.BinFloat) -> Self
pub fn BinFloatResult::err(@arithmetic.ArithmeticError) -> Self
pub fn BinFloatResult::from_result(Result[@bin_float.BinFloat, @arithmetic.ArithmeticError]) -> Self

对每个 r 都有 from_result(r).result() == r，而 ok(x) 是设计页面中所述单子的单位元。

`BinFloatResult::from_int`, `from_coefficient`, `from_double`, `from_float`

这些构造函数通过对应的 BinFloat 构造函数，由 MoonBit 数值构建一个成功的包装值。

pub fn BinFloatResult::from_int(Int, precision? : Int) -> Self
pub fn BinFloatResult::from_coefficient(@bin_float.BinCoeff, precision? : Int, negative? : Bool) -> Self
pub fn BinFloatResult::from_double(Double, precision? : Int) -> Self
pub fn BinFloatResult::from_float(Float, precision? : Int) -> Self

构造子	默认 `precision`	委托给
`from_int`	53	`BinFloat::from_int`
`from_coefficient`	53（`negative` 默认为 `false`）	`BinFloat::from_coefficient`
`from_double`	53	`BinFloat::from_double`
`from_float`	24	`BinFloat::from_float`

它们从不产生错误：NaN 与无穷输入会变成成功的 NaN 或无穷值；无法容纳于 precision 的值按被委托的构造函数那样以就近舍入（偶数优先）处理。

观察

`BinFloatResult::result`, `is_ok`, `is_err`

这些方法暴露被包装的 Result 并检测其分支。

pub fn BinFloatResult::result(Self) -> Result[@bin_float.BinFloat, @arithmetic.ArithmeticError]
pub fn BinFloatResult::is_ok(Self) -> Bool
pub fn BinFloatResult::is_err(Self) -> Bool

is_err(r) == !is_ok(r)。只在处理错误的边界处调用一次 result()。

组合

`BinFloatResult::map`

map(f) 将一个不会失败的函数作用于成功值，错误则保持不变。

pub fn BinFloatResult::map(Self, (@bin_float.BinFloat) -> @bin_float.BinFloat) -> Self

$\texttt{map}(\texttt{Ok}(x), f) = \texttt{Ok}(f(x))$ 且 $\texttt{map}(\texttt{Err}(e), f) = \texttt{Err}(e)$ ；遇到错误时不会调用 f。map 永远不会把成功值变成错误。

`BinFloatResult::bind`

bind(f) 应用一个自身可能失败的函数。

pub fn BinFloatResult::bind(Self, (@bin_float.BinFloat) -> Self) -> Self

$\texttt{bind}(\texttt{Ok}(x), f) = f(x)$ 且 $\texttt{bind}(\texttt{Err}(e), f) = \texttt{Err}(e)$ 。与 ok 一起，它满足单子律（左单位律、右单位律与结合律），推导见设计页面。

///|
test "map and bind" {
  let halve = fn(x : @bin_float.BinFloat) { x * @bin_float.BinFloat::from_double(0.5) }
  let positive = fn(x : @bin_float.BinFloat) {
    if x.sign() == @def.Sign::Positive {
      @bin_float_checked.BinFloatResult::ok(x)
    } else {
      @bin_float_checked.BinFloatResult::err(
        @lf_arith.ArithmeticError::domain_error("expected a positive value"),
      )
    }
  }
  let good = @bin_float_checked.BinFloatResult::from_int(3).map(halve).bind(positive)
  inspect(show(good), content="3p-1")
  let bad = @bin_float_checked.BinFloatResult::from_int(-3).bind(positive).map(halve)
  inspect(show(bad), content="error: expected a positive value")
}

一元值映射

`neg`, `abs`, `ulp`, `normalized`, `with_precision`

这些方法是同名 BinFloat 方法的 map，从不引入错误。

pub fn BinFloatResult::neg(Self) -> Self
pub fn BinFloatResult::abs(Self) -> Self
pub fn BinFloatResult::ulp(Self) -> Self
pub fn BinFloatResult::normalized(Self) -> Self
pub fn BinFloatResult::with_precision(Self, Int, @arithmetic.RoundingMode) -> Self

with_precision(p, mode) 以方向 mode 舍入到 $\max(1,p)$ 位，指数无界；ulp 是该值精度下的末位单位（对非有限值为 NaN）。

算术

`add`, `sub`, `mul`

这些方法用 BinFloat 运算符组合两个包装值。

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

若 self 是错误则返回它；否则若 other 是错误则返回该错误；否则结果为 Ok(lhs op rhs)。BinFloat 运算符以两个操作数中较大的精度进行就近舍入（偶数优先），且从不失败：诸如 $\infty - \infty$ 的无效情形会产生一个成功的 NaN。

`div`

div 对两个包装值做除法，并报告除以零。

pub fn BinFloatResult::div(Self, Self) -> Self

在处理完操作数错误（先左后右）之后，结果为 BinFloat::div_checked(lhs, rhs)：当除数是有限的零（ $\pm 0$ ）时，无论被除数为何（包括 $0/0$ 和 NaN $/0$ ），都返回 DivisionByZero 错误，否则返回舍入后的商。

`min`, `max`

这些方法用 BinFloat::min / BinFloat::max 取较小或较大的操作数，二者会忽略 NaN 操作数而取另一个。

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

`clamp`

clamp(min~, max~) 将值限制在一个区间内。

pub fn BinFloatResult::clamp(Self, min~ : Self, max~ : Self) -> Self

错误按 self、min、max 的顺序选取；之后 BinFloat::clamp_checked 在某个边界为 NaN 或 min > max 时返回 DomainError，否则返回截断后的值。

///|
test "arithmetic keeps the first error" {
  let one = @bin_float_checked.BinFloatResult::from_int(1)
  let zero = @bin_float_checked.BinFloatResult::from_int(0)
  inspect(show(one + one * one), content="1p1")
  inspect(show(one / zero), content="error: division by zero")
  let left = @bin_float_checked.BinFloatResult::err(
    @lf_arith.ArithmeticError::unsupported("left"),
  )
  inspect(show(left + one / zero), content="error: left")
  inspect(show(one / zero + left), content="error: division by zero")
  let clamped = @bin_float_checked.BinFloatResult::from_int(5).clamp(
    min=zero,
    max=@bin_float_checked.BinFloatResult::from_int(3),
  )
  inspect(show(clamped), content="3p0")
  let reversed = one.clamp(min=@bin_float_checked.BinFloatResult::from_int(3), max=zero)
  inspect(show(reversed), content="error: min must not exceed max")
}

上下文式算术

`add_ctx`, `sub_ctx`, `mul_ctx`, `div_ctx`

这些方法在显式的 BinaryContext 下执行 BinFloat::*_ctx 运算，只保留其值。

pub fn BinFloatResult::add_ctx(Self, Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::sub_ctx(Self, Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::mul_ctx(Self, Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::div_ctx(Self, Self, @bin_float.BinaryContext) -> Self

结果具有上下文的精度、舍入方向和指数范围，并按 IEEE 处理上溢、下溢和次正规数。该步骤的 BinaryFlags 会被丢弃，IEEE 异常情形均为成功值：div_ctx 除以零返回 $\pm\infty$ （ $0/0$ 则为 NaN），而 div 返回错误。若需要标志，请直接使用 bin_float。

///|
test "context arithmetic rounds to the context and drops flags" {
  let binary32 = @bin_float.BinaryContext::binary32()
  let tenth = @bin_float_checked.BinFloatResult::from_double(0.1)
  let zero = @bin_float_checked.BinFloatResult::from_int(0)
  inspect(show(tenth.add_ctx(zero, binary32)), content="13421773p-27")
  let one = @bin_float_checked.BinFloatResult::from_int(1)
  inspect(show(one.div_ctx(zero, binary32)), content="inf")
  inspect(show(one.div(zero)), content="error: division by zero")
}

幂与方根

`sqrt`, `sqrt_ctx`

sqrt 以操作数的精度求平方根；sqrt_ctx 在上下文下求平方根。

pub fn BinFloatResult::sqrt(Self) -> Self
pub fn BinFloatResult::sqrt_ctx(Self, @bin_float.BinaryContext) -> Self

sqrt 即 BinFloat::sqrt，对负的非零参数（包括 $-\infty$ ）返回 DomainError； $\sqrt{-0} = -0$ ，NaN 得到 NaN。sqrt_ctx 从不失败：负参数得到一个成功的 NaN（invalid 标志被丢弃）。

`pow_nat`, `pow_int`, `pow_int_ctx`, `pown`, `pown_ctx`

这些方法将值提升到整数次幂。

pub fn BinFloatResult::pow_nat(Self, UInt) -> Self
pub fn BinFloatResult::pow_int(Self, Int) -> Self
pub fn BinFloatResult::pow_int_ctx(Self, Int, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::pown(Self, Int) -> Self
pub fn BinFloatResult::pown_ctx(Self, Int, @bin_float.BinaryContext) -> Self

pow_nat(n) 以 ArithmeticContext::new(x.precision()) 调用 Luna-Flow/arithmetic 的 trait 方法 PowNatChecked::pow_nat_checked，bin_float 将其映射为该精度下、采用就近舍入（偶数优先）的无界二进制上下文。pow_int 与 pown（同一运算的 IEEE 名称）在底数为零且指数为负时返回 DivisionByZero 错误，否则以操作数的精度返回舍入后的幂。_ctx 形式从不失败，在底数为零且指数为负时返回 $\pm\infty$ 。

`rootn`, `rootn_ctx`

rootn(n) 用 BinFloat::try_rootn_ctx 计算实数 $n$ 次方根。

pub fn BinFloatResult::rootn(Self, Int) -> Self
pub fn BinFloatResult::rootn_ctx(Self, Int, @bin_float.BinaryContext) -> Self

rootn 使用操作数精度下的无界上下文；rootn_ctx 使用给定的上下文。二者在次数为 $0$ 以及对负数开偶次方根时都报告 DomainError，并且可能报告 CertificationFailure。负数的奇次方根为负：rootn(-8, 3) 为 $-2$ 。

`pow`, `pow_ctx`

pow(y) 用 BinFloat::try_pow_ctx 计算二进制指数下的 $x^{y}$ 。

pub fn BinFloatResult::pow(Self, Self) -> Self
pub fn BinFloatResult::pow_ctx(Self, Self, @bin_float.BinaryContext) -> Self

pow 使用较大操作数精度下的无界上下文。操作数的错误优先（先底数，后指数）；运算本身在底数为负且指数非整数时（例如 $(-2)^{0.5}$ ）报告 DomainError，并且可能报告 CertificationFailure。

`hypot`, `hypot_ctx`

hypot(y) 用 BinFloat::try_hypot_ctx 计算 $\sqrt{x^2 + y^2}$ ，中间过程不会上溢。

pub fn BinFloatResult::hypot(Self, Self) -> Self
pub fn BinFloatResult::hypot_ctx(Self, Self, @bin_float.BinaryContext) -> Self

hypot 使用较大操作数精度下的无界上下文。

///|
test "powers and roots" {
  let r = fn(n : Int) { @bin_float_checked.BinFloatResult::from_int(n) }
  inspect(show(@bin_float_checked.BinFloatResult::from_int(81, precision=48).sqrt()), content="9p0")
  inspect(show(r(-4).sqrt()), content="error: sqrt requires a non-negative value")
  inspect(show(r(3).pow_nat(10)), content="59049p0")
  inspect(show(r(0).pow_int(-1)), content="error: negative exponent requires a non-zero base")
  inspect(show(r(-8).rootn(3)), content="-1p1")
  inspect(show(r(8).rootn(0)), content="error: rootn degree must not be zero")
  inspect(show(r(3).hypot(r(4))), content="5p0")
}

初等函数

指数与对数

exp、exp2、exp10、expm1、ln、log2、log10、log1p 和 exp_ln 应用 bin_float 中经过认证的初等函数。

pub fn BinFloatResult::exp(Self) -> Self
pub fn BinFloatResult::exp_ctx(Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::exp2(Self) -> Self
pub fn BinFloatResult::exp2_ctx(Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::exp10(Self) -> Self
pub fn BinFloatResult::exp10_ctx(Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::expm1(Self) -> Self
pub fn BinFloatResult::expm1_ctx(Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::ln(Self) -> Self
pub fn BinFloatResult::ln_ctx(Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::log2(Self) -> Self
pub fn BinFloatResult::log2_ctx(Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::log10(Self) -> Self
pub fn BinFloatResult::log10_ctx(Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::log1p(Self) -> Self
pub fn BinFloatResult::log1p_ctx(Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::exp_ln(Self) -> Self
pub fn BinFloatResult::exp_ln_ctx(Self, @bin_float.BinaryContext) -> Self

每个 name 方法都是 BinFloat::try_name_ctx 在 BinaryContext::unbounded(x.precision()) 下的 bind，即以就近舍入（偶数优先）舍入到操作数的精度，且无指数限制；每个 name_ctx 方法则改用给定的上下文。结果是正确舍入的。错误即 try_* 函数的错误：对负数取对数以及 log1p 的参数小于 $-1$ 时为 DomainError；当无法在细化预算内认证舍入时为 CertificationFailure。极点是值而非错误： $\ln 0 = -\infty$ 。exp_ln 将 $\ln(\exp(x))$ 作为一个融合运算求值；它仅在 $|x| \le 1/8$ 时经过认证，对更大的有限参数返回 CertificationFailure（阶段为 RangeReduction，原因为 RangeNotCertified）。

三角函数

sin、cos、tan、sinpi、cospi、tanpi、asin、acos、atan 和 atan2 遵循相同的模式。

pub fn BinFloatResult::sin(Self) -> Self
pub fn BinFloatResult::sin_ctx(Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::cos(Self) -> Self
pub fn BinFloatResult::cos_ctx(Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::tan(Self) -> Self
pub fn BinFloatResult::tan_ctx(Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::sinpi(Self) -> Self
pub fn BinFloatResult::sinpi_ctx(Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::cospi(Self) -> Self
pub fn BinFloatResult::cospi_ctx(Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::tanpi(Self) -> Self
pub fn BinFloatResult::tanpi_ctx(Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::asin(Self) -> Self
pub fn BinFloatResult::asin_ctx(Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::acos(Self) -> Self
pub fn BinFloatResult::acos_ctx(Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::atan(Self) -> Self
pub fn BinFloatResult::atan_ctx(Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::atan2(Self, Self) -> Self
pub fn BinFloatResult::atan2_ctx(Self, Self, @bin_float.BinaryContext) -> Self

sinpi(x) 即 $\sin(\pi x)$ ，其余类推。asin 和 acos 在 $[-1, 1]$ 之外报告 DomainError；tanpi 在半整数处返回 $\pm\infty$ 。atan2(self, abscissa) 是点 $(\text{abscissa}, \text{self})$ 的辐角；其错误按纵坐标、横坐标、运算的顺序选取，atan2 的上下文使用较大的操作数精度。

双曲函数

sinh、cosh、tanh、asinh、acosh 和 atanh 遵循相同的模式。

pub fn BinFloatResult::sinh(Self) -> Self
pub fn BinFloatResult::sinh_ctx(Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::cosh(Self) -> Self
pub fn BinFloatResult::cosh_ctx(Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::tanh(Self) -> Self
pub fn BinFloatResult::tanh_ctx(Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::asinh(Self) -> Self
pub fn BinFloatResult::asinh_ctx(Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::acosh(Self) -> Self
pub fn BinFloatResult::acosh_ctx(Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::atanh(Self) -> Self
pub fn BinFloatResult::atanh_ctx(Self, @bin_float.BinaryContext) -> Self

acosh 在小于 $1$ 时报告 DomainError，atanh 在 $|x| > 1$ 时报告； $\operatorname{atanh}(\pm 1) = \pm\infty$ 。

///|
test "elementary functions" {
  let r = fn(n : Int) { @bin_float_checked.BinFloatResult::from_int(n) }
  inspect(show(r(2).ln()), content="6243314768165359p-53")
  inspect(
    show(r(2).ln_ctx(@bin_float.BinaryContext::unbounded(24))),
    content="1453635p-21",
  )
  inspect(show(r(0).ln()), content="-inf")
  inspect(show(r(-4).ln()), content="error: ln requires a positive value")
  inspect(show(r(2).asin()), content="error: asin requires an input in [-1, 1]")
  inspect(show(r(3).exp_ln()), content="error: certified evaluation failed for exp_ln")
  inspect(show(r(0).exp().ln()), content="0")
}

trait 实现

`Add`, `Sub`, `Mul`, `Div`, `Neg`

运算符 +、-、*、/ 和一元 - 调用 add、sub、mul、div 和 neg。

pub impl Add for BinFloatResult
pub impl Sub for BinFloatResult
pub impl Mul for BinFloatResult
pub impl Div for BinFloatResult
pub impl Neg for BinFloatResult

因此，包装值上的 / 会报告除以零，而普通 BinFloat 值上的 / 返回无穷。

已弃用

`BinFloatResult::flat_map`

flat_map 是 bind 的旧名称。请将 r.flat_map(f) 替换为 r.bind(f)。

#deprecated
pub fn BinFloatResult::flat_map(Self, (@bin_float.BinFloat) -> Self) -> Self

完整公共接口

以下快照是该包完整的生成接口。

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

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

// Values

// Errors

// Types and methods
pub struct BinFloatResult {
  // private fields
}
pub fn BinFloatResult::abs(Self) -> Self
pub fn BinFloatResult::acos(Self) -> Self
pub fn BinFloatResult::acos_ctx(Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::acosh(Self) -> Self
pub fn BinFloatResult::acosh_ctx(Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::add(Self, Self) -> Self
pub fn BinFloatResult::add_ctx(Self, Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::asin(Self) -> Self
pub fn BinFloatResult::asin_ctx(Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::asinh(Self) -> Self
pub fn BinFloatResult::asinh_ctx(Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::atan(Self) -> Self
pub fn BinFloatResult::atan2(Self, Self) -> Self
pub fn BinFloatResult::atan2_ctx(Self, Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::atan_ctx(Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::atanh(Self) -> Self
pub fn BinFloatResult::atanh_ctx(Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::bind(Self, (@bin_float.BinFloat) -> Self) -> Self
pub fn BinFloatResult::clamp(Self, min~ : Self, max~ : Self) -> Self
pub fn BinFloatResult::cos(Self) -> Self
pub fn BinFloatResult::cos_ctx(Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::cosh(Self) -> Self
pub fn BinFloatResult::cosh_ctx(Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::cospi(Self) -> Self
pub fn BinFloatResult::cospi_ctx(Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::div(Self, Self) -> Self
pub fn BinFloatResult::div_ctx(Self, Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::err(@arithmetic.ArithmeticError) -> Self
pub fn BinFloatResult::exp(Self) -> Self
pub fn BinFloatResult::exp10(Self) -> Self
pub fn BinFloatResult::exp10_ctx(Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::exp2(Self) -> Self
pub fn BinFloatResult::exp2_ctx(Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::exp_ctx(Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::exp_ln(Self) -> Self
pub fn BinFloatResult::exp_ln_ctx(Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::expm1(Self) -> Self
pub fn BinFloatResult::expm1_ctx(Self, @bin_float.BinaryContext) -> Self
#deprecated
pub fn BinFloatResult::flat_map(Self, (@bin_float.BinFloat) -> Self) -> Self
pub fn BinFloatResult::from_coefficient(@bin_float.BinCoeff, precision? : Int, negative? : Bool) -> Self
pub fn BinFloatResult::from_double(Double, precision? : Int) -> Self
pub fn BinFloatResult::from_float(Float, precision? : Int) -> Self
pub fn BinFloatResult::from_int(Int, precision? : Int) -> Self
pub fn BinFloatResult::from_result(Result[@bin_float.BinFloat, @arithmetic.ArithmeticError]) -> Self
pub fn BinFloatResult::hypot(Self, Self) -> Self
pub fn BinFloatResult::hypot_ctx(Self, Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::is_err(Self) -> Bool
pub fn BinFloatResult::is_ok(Self) -> Bool
pub fn BinFloatResult::ln(Self) -> Self
pub fn BinFloatResult::ln_ctx(Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::log10(Self) -> Self
pub fn BinFloatResult::log10_ctx(Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::log1p(Self) -> Self
pub fn BinFloatResult::log1p_ctx(Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::log2(Self) -> Self
pub fn BinFloatResult::log2_ctx(Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::map(Self, (@bin_float.BinFloat) -> @bin_float.BinFloat) -> Self
pub fn BinFloatResult::max(Self, Self) -> Self
pub fn BinFloatResult::min(Self, Self) -> Self
pub fn BinFloatResult::mul(Self, Self) -> Self
pub fn BinFloatResult::mul_ctx(Self, Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::neg(Self) -> Self
pub fn BinFloatResult::normalized(Self) -> Self
pub fn BinFloatResult::ok(@bin_float.BinFloat) -> Self
pub fn BinFloatResult::pow(Self, Self) -> Self
pub fn BinFloatResult::pow_ctx(Self, Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::pow_int(Self, Int) -> Self
pub fn BinFloatResult::pow_int_ctx(Self, Int, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::pow_nat(Self, UInt) -> Self
pub fn BinFloatResult::pown(Self, Int) -> Self
pub fn BinFloatResult::pown_ctx(Self, Int, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::result(Self) -> Result[@bin_float.BinFloat, @arithmetic.ArithmeticError]
pub fn BinFloatResult::rootn(Self, Int) -> Self
pub fn BinFloatResult::rootn_ctx(Self, Int, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::sin(Self) -> Self
pub fn BinFloatResult::sin_ctx(Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::sinh(Self) -> Self
pub fn BinFloatResult::sinh_ctx(Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::sinpi(Self) -> Self
pub fn BinFloatResult::sinpi_ctx(Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::sqrt(Self) -> Self
pub fn BinFloatResult::sqrt_ctx(Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::sub(Self, Self) -> Self
pub fn BinFloatResult::sub_ctx(Self, Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::tan(Self) -> Self
pub fn BinFloatResult::tan_ctx(Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::tanh(Self) -> Self
pub fn BinFloatResult::tanh_ctx(Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::tanpi(Self) -> Self
pub fn BinFloatResult::tanpi_ctx(Self, @bin_float.BinaryContext) -> Self
pub fn BinFloatResult::ulp(Self) -> Self
pub fn BinFloatResult::with_precision(Self, Int, @arithmetic.RoundingMode) -> Self
pub impl Add for BinFloatResult
pub impl Div for BinFloatResult
pub impl Mul for BinFloatResult
pub impl Neg for BinFloatResult
pub impl Sub for BinFloatResult

// Type aliases

// Traits

bin_float_checked API

包装类型

BinFloatResult

构造

BinFloatResult::ok, BinFloatResult::err, BinFloatResult::from_result

BinFloatResult::from_int, from_coefficient, from_double, from_float

观察

BinFloatResult::result, is_ok, is_err

组合

BinFloatResult::map

BinFloatResult::bind