Struct CachedFBig 

pub struct CachedFBig<R: Round = Zero, const B: Word = 2> { /* private fields */ }

A floating-point number that carries a shared handle to a ConstCache.

It is functionally an FBig: same in-memory representation (fbig), plus an Rc<RefCell<ConstCache>> handle. The difference is that the transcendental operations (ln, exp, sin, cos, …, pi, base conversion) thread that handle into the underlying Context methods, so they reuse and progressively extend the cached exact binary-splitting state instead of recomputing constants from scratch on every call.

Context/FBig themselves stay Copy + Send + Sync + no_std (so static_fbig! keeps working); only this cached wrapper is !Send + !Sync, because it shares state through an Rc<RefCell<..>>. To share one cache across threads, build an analogous type over Arc<Mutex<ConstCache>> instead (the Context methods accept Option<&mut ConstCache>, independent of the container).

Every value-producing operation returns a CachedFBig that preserves the handle, so (a + b).ln().exp() stays cached throughout — no silent cache loss. When two CachedFBig values with different cache handles interact in a binary operation, the LHS (left-hand-side) cache is preserved in the result. For FBig op CachedFBig, the CachedFBig operand’s cache is preserved.

Examples

use core::cell::RefCell;
use core::str::FromStr;
use dashu_float::{CachedFBig, ConstCache, Context};
use dashu_float::round::mode::HalfAway;
use std::rc::Rc;

let cache = Rc::new(RefCell::new(ConstCache::new()));
// build a cached decimal number 1.234
let x = CachedFBig::<HalfAway, 10>::with_cache(
    dashu_float::Repr::new(1234.into(), -3),
    Context::new(50),
);

// ln / exp reuse the same shared cache handle
let _ = x.clone().ln().exp();

Implementations

impl<R: Round, const B: Word> CachedFBig<R, B>

pub fn new(value: FBig<R, B>, cache: Rc<RefCell<ConstCache>>) -> Self

Wrap an FBig, sharing the given cache handle.

pub fn from_repr( repr: Repr<B>, context: Context<R>, cache: Rc<RefCell<ConstCache>>, ) -> Self

Build from raw parts, sharing the given cache handle.

pub fn with_cache(repr: Repr<B>, context: Context<R>) -> Self

Build from raw parts with a fresh, exclusive cache.

pub fn as_fbig(&self) -> &FBig<R, B>

Borrow the inner FBig.

pub fn into_fbig(self) -> FBig<R, B>

Drop the cache handle and return the underlying FBig.

pub fn cache(&self) -> impl Deref<Target = ConstCache> + '_

Borrow the shared constant cache immutably.

Use this to inspect cache state, e.g. cached.cache().total_terms().

pub fn clear_cache(&self)

Clear all cached constant state, freeing the underlying memory.

The next transcendental operation will recompute constants from scratch.

pub fn pi(precision: usize, cache: &Rc<RefCell<ConstCache>>) -> Self

π at precision base-B digits, reusing/extending cache.

pub const fn precision(&self) -> usize

Maximum precision set for the number (see FBig::precision).

pub fn digits(&self) -> usize

Number of significant digits (see FBig::digits).

pub const fn context(&self) -> Context<R>

The associated context.

pub const fn repr(&self) -> &Repr<B>

The underlying representation.

pub fn into_repr(self) -> Repr<B>

Consume and return the underlying representation.

pub const fn sign(&self) -> Sign

Sign of the number (see FBig::sign).

pub fn with_precision(&self, precision: usize) -> Rounded<Self>

Change precision, preserving the handle (see FBig::with_precision).

pub fn with_rounding<NewR: Round>(&self) -> CachedFBig<NewR, B>

Change rounding mode, preserving the handle (see FBig::with_rounding).

impl<R: Round, const B: Word> CachedFBig<R, B>

pub fn ulp(&self) -> Self

ULP of the number (see FBig::ulp).

pub fn to_int(&self) -> Rounded<IBig>

Convert to an integer (see FBig::to_int).

pub fn to_f32(&self) -> Rounded<f32>

Convert to f32 (see FBig::to_f32).

pub fn to_f64(&self) -> Rounded<f64>

Convert to f64 (see FBig::to_f64).

pub fn from_parts(significand: IBig, exponent: isize) -> Self

Construct from significand + exponent, with a fresh cache (see FBig::from_parts).

impl<R: Round, const B: Word> CachedFBig<R, B>

pub fn ln(&self) -> CachedFBig<R, B>

See FBig::ln.

pub fn ln_1p(&self) -> CachedFBig<R, B>

See FBig::ln_1p.

pub fn exp(&self) -> CachedFBig<R, B>

See FBig::exp.

pub fn exp_m1(&self) -> CachedFBig<R, B>

See FBig::exp_m1.

pub fn sqrt(&self) -> CachedFBig<R, B>

See FBig::sqrt.

pub fn inv(&self) -> CachedFBig<R, B>

See FBig::inv.

pub fn sin(&self) -> CachedFBig<R, B>

See FBig::sin.

pub fn cos(&self) -> CachedFBig<R, B>

See FBig::cos.

pub fn tan(&self) -> CachedFBig<R, B>

See FBig::tan.

pub fn asin(&self) -> CachedFBig<R, B>

See FBig::asin.

pub fn acos(&self) -> CachedFBig<R, B>

See FBig::acos.

pub fn atan(&self) -> CachedFBig<R, B>

See FBig::atan.

pub fn sinh(&self) -> CachedFBig<R, B>

See FBig::sinh.

pub fn cosh(&self) -> CachedFBig<R, B>

See FBig::cosh.

pub fn tanh(&self) -> CachedFBig<R, B>

See FBig::tanh.

pub fn asinh(&self) -> CachedFBig<R, B>

See FBig::asinh.

pub fn acosh(&self) -> CachedFBig<R, B>

See FBig::acosh.

pub fn atanh(&self) -> CachedFBig<R, B>

See FBig::atanh.

pub fn powi(&self, exp: IBig) -> CachedFBig<R, B>

See FBig::powi.

pub fn sqr(&self) -> CachedFBig<R, B>

See FBig::sqr.

pub fn cubic(&self) -> CachedFBig<R, B>

See FBig::cubic.

pub fn powf(&self, exp: &Self) -> Self

self^exp (see FBig::powf).

pub fn sin_cos(&self) -> (Self, Self)

Sine and cosine together (see FBig::sin_cos).

pub fn sinh_cosh(&self) -> (Self, Self)

Hyperbolic sine and cosine together (see FBig::sinh_cosh).

pub fn atan2(&self, x: &Self) -> Self

atan2(y, x) (see FBig::atan2).

Trait Implementations

impl<R: Round, const B: Word> Abs for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The type of the absolute value.

fn abs(self) -> Self::Output

Compute the absolute value.

impl<R: Round, const B: Word> AbsOrd for CachedFBig<R, B>

fn abs_cmp(&self, other: &Self) -> Ordering

Compare the magnitude of self against the magnitude of rhs.

impl<R: Round, const B: Word> AbsOrd<CachedFBig<R, B>> for UBig

fn abs_cmp(&self, other: &CachedFBig<R, B>) -> Ordering

Compare the magnitude of self against the magnitude of rhs.

impl<R: Round, const B: Word> AbsOrd<CachedFBig<R, B>> for IBig

fn abs_cmp(&self, other: &CachedFBig<R, B>) -> Ordering

Compare the magnitude of self against the magnitude of rhs.

impl<R: Round, const B: Word> AbsOrd<IBig> for CachedFBig<R, B>

fn abs_cmp(&self, other: &IBig) -> Ordering

Compare the magnitude of self against the magnitude of rhs.

impl<R: Round, const B: Word> AbsOrd<UBig> for CachedFBig<R, B>

fn abs_cmp(&self, other: &UBig) -> Ordering

Compare the magnitude of self against the magnitude of rhs.

impl<R: Round, const B: Word> Add for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r CachedFBig<R, B>> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &'r CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r CachedFBig<R, B>> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &'r CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r CachedFBig<R, B>> for FBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r CachedFBig<R, B>> for &'l FBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r CachedFBig<R, B>> for u8

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r CachedFBig<R, B>> for &'l u8

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r CachedFBig<R, B>> for u16

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r CachedFBig<R, B>> for &'l u16

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r CachedFBig<R, B>> for u32

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r CachedFBig<R, B>> for &'l u32

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r CachedFBig<R, B>> for u64

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r CachedFBig<R, B>> for &'l u64

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r CachedFBig<R, B>> for u128

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r CachedFBig<R, B>> for &'l u128

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r CachedFBig<R, B>> for usize

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r CachedFBig<R, B>> for &'l usize

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r CachedFBig<R, B>> for UBig

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r CachedFBig<R, B>> for &'l UBig

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r CachedFBig<R, B>> for i8

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r CachedFBig<R, B>> for &'l i8

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r CachedFBig<R, B>> for i16

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r CachedFBig<R, B>> for &'l i16

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r CachedFBig<R, B>> for i32

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r CachedFBig<R, B>> for &'l i32

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r CachedFBig<R, B>> for i64

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r CachedFBig<R, B>> for &'l i64

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r CachedFBig<R, B>> for i128

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r CachedFBig<R, B>> for &'l i128

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r CachedFBig<R, B>> for isize

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r CachedFBig<R, B>> for &'l isize

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r CachedFBig<R, B>> for IBig

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r CachedFBig<R, B>> for &'l IBig

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r FBig<R, B>> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r FBig<R, B>> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r IBig> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &IBig) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r IBig> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &IBig) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r UBig> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &UBig) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r UBig> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &UBig) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r i8> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &i8) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r i8> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &i8) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r i16> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &i16) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r i16> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &i16) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r i32> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &i32) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r i32> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &i32) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r i64> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &i64) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r i64> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &i64) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r i128> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &i128) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r i128> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &i128) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r isize> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &isize) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r isize> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &isize) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r u8> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &u8) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r u8> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &u8) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r u16> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &u16) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r u16> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &u16) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r u32> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &u32) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r u32> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &u32) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r u64> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &u64) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r u64> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &u64) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r u128> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &u128) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r u128> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &u128) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r usize> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &usize) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r usize> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &usize) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<CachedFBig<R, B>> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<CachedFBig<R, B>> for FBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<CachedFBig<R, B>> for &'l FBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<CachedFBig<R, B>> for u8

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<CachedFBig<R, B>> for &'l u8

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<CachedFBig<R, B>> for u16

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<CachedFBig<R, B>> for &'l u16

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<CachedFBig<R, B>> for u32

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<CachedFBig<R, B>> for &'l u32

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<CachedFBig<R, B>> for u64

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<CachedFBig<R, B>> for &'l u64

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<CachedFBig<R, B>> for u128

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<CachedFBig<R, B>> for &'l u128

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<CachedFBig<R, B>> for usize

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<CachedFBig<R, B>> for &'l usize

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<CachedFBig<R, B>> for UBig

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<CachedFBig<R, B>> for &'l UBig

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<CachedFBig<R, B>> for i8

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<CachedFBig<R, B>> for &'l i8

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<CachedFBig<R, B>> for i16

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<CachedFBig<R, B>> for &'l i16

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<CachedFBig<R, B>> for i32

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<CachedFBig<R, B>> for &'l i32

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<CachedFBig<R, B>> for i64

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<CachedFBig<R, B>> for &'l i64

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<CachedFBig<R, B>> for i128

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<CachedFBig<R, B>> for &'l i128

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<CachedFBig<R, B>> for isize

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<CachedFBig<R, B>> for &'l isize

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<CachedFBig<R, B>> for IBig

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<CachedFBig<R, B>> for &'l IBig

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<FBig<R, B>> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<FBig<R, B>> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: FBig<R, B>) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<IBig> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: IBig) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<IBig> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: IBig) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<UBig> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: UBig) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<UBig> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: UBig) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<i8> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: i8) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<i8> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: i8) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<i16> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: i16) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<i16> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: i16) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<i32> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: i32) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<i32> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: i32) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<i64> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: i64) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<i64> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: i64) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<i128> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: i128) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<i128> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: i128) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<isize> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: isize) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<isize> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: isize) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<u8> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: u8) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<u8> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: u8) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<u16> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: u16) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<u16> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: u16) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<u32> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: u32) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<u32> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: u32) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<u64> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: u64) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<u64> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: u64) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<u128> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: u128) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<u128> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: u128) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<usize> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: usize) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<usize> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: usize) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> AddAssign for CachedFBig<R, B>

fn add_assign(&mut self, rhs: CachedFBig<R, B>)

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<&FBig<R, B>> for CachedFBig<R, B>

fn add_assign(&mut self, rhs: &FBig<R, B>)

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<&IBig> for CachedFBig<R, B>

fn add_assign(&mut self, rhs: &IBig)

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<&UBig> for CachedFBig<R, B>

fn add_assign(&mut self, rhs: &UBig)

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<&i8> for CachedFBig<R, B>

fn add_assign(&mut self, rhs: &i8)

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<&i16> for CachedFBig<R, B>

fn add_assign(&mut self, rhs: &i16)

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<&i32> for CachedFBig<R, B>

fn add_assign(&mut self, rhs: &i32)

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<&i64> for CachedFBig<R, B>

fn add_assign(&mut self, rhs: &i64)

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<&i128> for CachedFBig<R, B>

fn add_assign(&mut self, rhs: &i128)

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<&isize> for CachedFBig<R, B>

fn add_assign(&mut self, rhs: &isize)

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<&u8> for CachedFBig<R, B>

fn add_assign(&mut self, rhs: &u8)

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<&u16> for CachedFBig<R, B>

fn add_assign(&mut self, rhs: &u16)

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<&u32> for CachedFBig<R, B>

fn add_assign(&mut self, rhs: &u32)

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<&u64> for CachedFBig<R, B>

fn add_assign(&mut self, rhs: &u64)

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<&u128> for CachedFBig<R, B>

fn add_assign(&mut self, rhs: &u128)

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<&usize> for CachedFBig<R, B>

fn add_assign(&mut self, rhs: &usize)

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<FBig<R, B>> for CachedFBig<R, B>

fn add_assign(&mut self, rhs: FBig<R, B>)

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<IBig> for CachedFBig<R, B>

fn add_assign(&mut self, rhs: IBig)

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<UBig> for CachedFBig<R, B>

fn add_assign(&mut self, rhs: UBig)

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<i8> for CachedFBig<R, B>

fn add_assign(&mut self, rhs: i8)

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<i16> for CachedFBig<R, B>

fn add_assign(&mut self, rhs: i16)

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<i32> for CachedFBig<R, B>

fn add_assign(&mut self, rhs: i32)

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<i64> for CachedFBig<R, B>

fn add_assign(&mut self, rhs: i64)

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<i128> for CachedFBig<R, B>

fn add_assign(&mut self, rhs: i128)

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<isize> for CachedFBig<R, B>

fn add_assign(&mut self, rhs: isize)

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<u8> for CachedFBig<R, B>

fn add_assign(&mut self, rhs: u8)

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<u16> for CachedFBig<R, B>

fn add_assign(&mut self, rhs: u16)

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<u32> for CachedFBig<R, B>

fn add_assign(&mut self, rhs: u32)

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<u64> for CachedFBig<R, B>

fn add_assign(&mut self, rhs: u64)

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<u128> for CachedFBig<R, B>

fn add_assign(&mut self, rhs: u128)

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<usize> for CachedFBig<R, B>

fn add_assign(&mut self, rhs: usize)

Performs the += operation.

impl<R: Round> Binary for CachedFBig<R, 2>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<R: Round, const B: Word> Clone for CachedFBig<R, B>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<R: Round, const B: Word> CubicRoot for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The type of the cubic root.

fn cbrt(&self) -> Self::Output

Compute the cubic root, rounded towards zero by default.

impl<R: Round, const B: Word> Debug for CachedFBig<R, B>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<R: Round, const B: Word> Default for CachedFBig<R, B>

fn default() -> Self

Default value: 0 with a fresh cache.

impl<R: Round, const B: Word> Display for CachedFBig<R, B>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<R: Round, const B: Word> Div for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r CachedFBig<R, B>> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &'r CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r CachedFBig<R, B>> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &'r CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r CachedFBig<R, B>> for FBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r CachedFBig<R, B>> for &'l FBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r CachedFBig<R, B>> for u8

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r CachedFBig<R, B>> for &'l u8

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r CachedFBig<R, B>> for u16

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r CachedFBig<R, B>> for &'l u16

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r CachedFBig<R, B>> for u32

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r CachedFBig<R, B>> for &'l u32

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r CachedFBig<R, B>> for u64

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r CachedFBig<R, B>> for &'l u64

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r CachedFBig<R, B>> for u128

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r CachedFBig<R, B>> for &'l u128

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r CachedFBig<R, B>> for usize

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r CachedFBig<R, B>> for &'l usize

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r CachedFBig<R, B>> for UBig

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r CachedFBig<R, B>> for &'l UBig

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r CachedFBig<R, B>> for i8

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r CachedFBig<R, B>> for &'l i8

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r CachedFBig<R, B>> for i16

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r CachedFBig<R, B>> for &'l i16

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r CachedFBig<R, B>> for i32

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r CachedFBig<R, B>> for &'l i32

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r CachedFBig<R, B>> for i64

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r CachedFBig<R, B>> for &'l i64

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r CachedFBig<R, B>> for i128

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r CachedFBig<R, B>> for &'l i128

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r CachedFBig<R, B>> for isize

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r CachedFBig<R, B>> for &'l isize

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r CachedFBig<R, B>> for IBig

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r CachedFBig<R, B>> for &'l IBig

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r FBig<R, B>> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r FBig<R, B>> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r IBig> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &IBig) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r IBig> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &IBig) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r UBig> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &UBig) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r UBig> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &UBig) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r i8> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &i8) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r i8> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &i8) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r i16> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &i16) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r i16> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &i16) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r i32> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &i32) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r i32> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &i32) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r i64> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &i64) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r i64> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &i64) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r i128> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &i128) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r i128> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &i128) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r isize> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &isize) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r isize> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &isize) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r u8> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &u8) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r u8> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &u8) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r u16> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &u16) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r u16> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &u16) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r u32> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &u32) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r u32> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &u32) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r u64> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &u64) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r u64> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &u64) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r u128> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &u128) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r u128> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &u128) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r usize> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &usize) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r usize> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &usize) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<CachedFBig<R, B>> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> Div<CachedFBig<R, B>> for FBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<CachedFBig<R, B>> for &'l FBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> Div<CachedFBig<R, B>> for u8

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<CachedFBig<R, B>> for &'l u8

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> Div<CachedFBig<R, B>> for u16

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<CachedFBig<R, B>> for &'l u16

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> Div<CachedFBig<R, B>> for u32

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<CachedFBig<R, B>> for &'l u32

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> Div<CachedFBig<R, B>> for u64

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<CachedFBig<R, B>> for &'l u64

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> Div<CachedFBig<R, B>> for u128

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<CachedFBig<R, B>> for &'l u128

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> Div<CachedFBig<R, B>> for usize

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<CachedFBig<R, B>> for &'l usize

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> Div<CachedFBig<R, B>> for UBig

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<CachedFBig<R, B>> for &'l UBig

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> Div<CachedFBig<R, B>> for i8

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<CachedFBig<R, B>> for &'l i8

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> Div<CachedFBig<R, B>> for i16

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<CachedFBig<R, B>> for &'l i16

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> Div<CachedFBig<R, B>> for i32

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<CachedFBig<R, B>> for &'l i32

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> Div<CachedFBig<R, B>> for i64

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<CachedFBig<R, B>> for &'l i64

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> Div<CachedFBig<R, B>> for i128

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<CachedFBig<R, B>> for &'l i128

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> Div<CachedFBig<R, B>> for isize

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<CachedFBig<R, B>> for &'l isize

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> Div<CachedFBig<R, B>> for IBig

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<CachedFBig<R, B>> for &'l IBig

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> Div<FBig<R, B>> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<FBig<R, B>> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: FBig<R, B>) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> Div<IBig> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: IBig) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<IBig> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: IBig) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> Div<UBig> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: UBig) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<UBig> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: UBig) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> Div<i8> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: i8) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<i8> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: i8) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> Div<i16> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: i16) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<i16> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: i16) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> Div<i32> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: i32) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<i32> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: i32) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> Div<i64> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: i64) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<i64> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: i64) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> Div<i128> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: i128) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<i128> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: i128) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> Div<isize> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: isize) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<isize> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: isize) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> Div<u8> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: u8) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<u8> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: u8) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> Div<u16> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: u16) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<u16> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: u16) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> Div<u32> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: u32) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<u32> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: u32) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> Div<u64> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: u64) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<u64> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: u64) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> Div<u128> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: u128) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<u128> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: u128) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> Div<usize> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: usize) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<usize> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: usize) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> DivAssign for CachedFBig<R, B>

fn div_assign(&mut self, rhs: CachedFBig<R, B>)

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<&FBig<R, B>> for CachedFBig<R, B>

fn div_assign(&mut self, rhs: &FBig<R, B>)

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<&IBig> for CachedFBig<R, B>

fn div_assign(&mut self, rhs: &IBig)

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<&UBig> for CachedFBig<R, B>

fn div_assign(&mut self, rhs: &UBig)

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<&i8> for CachedFBig<R, B>

fn div_assign(&mut self, rhs: &i8)

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<&i16> for CachedFBig<R, B>

fn div_assign(&mut self, rhs: &i16)

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<&i32> for CachedFBig<R, B>

fn div_assign(&mut self, rhs: &i32)

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<&i64> for CachedFBig<R, B>

fn div_assign(&mut self, rhs: &i64)

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<&i128> for CachedFBig<R, B>

fn div_assign(&mut self, rhs: &i128)

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<&isize> for CachedFBig<R, B>

fn div_assign(&mut self, rhs: &isize)

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<&u8> for CachedFBig<R, B>

fn div_assign(&mut self, rhs: &u8)

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<&u16> for CachedFBig<R, B>

fn div_assign(&mut self, rhs: &u16)

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<&u32> for CachedFBig<R, B>

fn div_assign(&mut self, rhs: &u32)

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<&u64> for CachedFBig<R, B>

fn div_assign(&mut self, rhs: &u64)

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<&u128> for CachedFBig<R, B>

fn div_assign(&mut self, rhs: &u128)

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<&usize> for CachedFBig<R, B>

fn div_assign(&mut self, rhs: &usize)

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<FBig<R, B>> for CachedFBig<R, B>

fn div_assign(&mut self, rhs: FBig<R, B>)

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<IBig> for CachedFBig<R, B>

fn div_assign(&mut self, rhs: IBig)

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<UBig> for CachedFBig<R, B>

fn div_assign(&mut self, rhs: UBig)

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<i8> for CachedFBig<R, B>

fn div_assign(&mut self, rhs: i8)

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<i16> for CachedFBig<R, B>

fn div_assign(&mut self, rhs: i16)

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<i32> for CachedFBig<R, B>

fn div_assign(&mut self, rhs: i32)

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<i64> for CachedFBig<R, B>

fn div_assign(&mut self, rhs: i64)

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<i128> for CachedFBig<R, B>

fn div_assign(&mut self, rhs: i128)

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<isize> for CachedFBig<R, B>

fn div_assign(&mut self, rhs: isize)

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<u8> for CachedFBig<R, B>

fn div_assign(&mut self, rhs: u8)

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<u16> for CachedFBig<R, B>

fn div_assign(&mut self, rhs: u16)

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<u32> for CachedFBig<R, B>

fn div_assign(&mut self, rhs: u32)

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<u64> for CachedFBig<R, B>

fn div_assign(&mut self, rhs: u64)

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<u128> for CachedFBig<R, B>

fn div_assign(&mut self, rhs: u128)

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<usize> for CachedFBig<R, B>

fn div_assign(&mut self, rhs: usize)

Performs the /= operation.

impl<R: Round, const B: Word> DivEuclid for CachedFBig<R, B>

type Output = IBig

The type of the quotient.

fn div_euclid(self, rhs: CachedFBig<R, B>) -> Self::Output

Compute the Euclidean quotient of self / rhs.

impl<'r, R: Round, const B: Word> DivEuclid<&'r CachedFBig<R, B>> for CachedFBig<R, B>

type Output = IBig

The type of the quotient.

fn div_euclid(self, rhs: &'r CachedFBig<R, B>) -> Self::Output

Compute the Euclidean quotient of self / rhs.

impl<'r, R: Round, const B: Word> DivEuclid<&'r CachedFBig<R, B>> for &CachedFBig<R, B>

type Output = IBig

The type of the quotient.

fn div_euclid(self, rhs: &'r CachedFBig<R, B>) -> Self::Output

Compute the Euclidean quotient of self / rhs.

impl<R: Round, const B: Word> DivEuclid<CachedFBig<R, B>> for &CachedFBig<R, B>

type Output = IBig

The type of the quotient.

fn div_euclid(self, rhs: CachedFBig<R, B>) -> Self::Output

Compute the Euclidean quotient of self / rhs.

impl<R: Round, const B: Word> DivRemEuclid for CachedFBig<R, B>

type OutputDiv = IBig

The type of the quotient.

type OutputRem = CachedFBig<R, B>

The type of the remainder.

fn div_rem_euclid( self, rhs: CachedFBig<R, B>, ) -> (Self::OutputDiv, Self::OutputRem)

Compute the Euclidean quotient and remainder at the same time.

impl<'r, R: Round, const B: Word> DivRemEuclid<&'r CachedFBig<R, B>> for CachedFBig<R, B>

type OutputDiv = IBig

The type of the quotient.

type OutputRem = CachedFBig<R, B>

The type of the remainder.

fn div_rem_euclid( self, rhs: &'r CachedFBig<R, B>, ) -> (Self::OutputDiv, Self::OutputRem)

Compute the Euclidean quotient and remainder at the same time.

impl<'r, R: Round, const B: Word> DivRemEuclid<&'r CachedFBig<R, B>> for &CachedFBig<R, B>

type OutputDiv = IBig

The type of the quotient.

type OutputRem = CachedFBig<R, B>

The type of the remainder.

fn div_rem_euclid( self, rhs: &'r CachedFBig<R, B>, ) -> (Self::OutputDiv, Self::OutputRem)

Compute the Euclidean quotient and remainder at the same time.

impl<R: Round, const B: Word> DivRemEuclid<CachedFBig<R, B>> for &CachedFBig<R, B>

type OutputDiv = IBig

The type of the quotient.

type OutputRem = CachedFBig<R, B>

The type of the remainder.

fn div_rem_euclid( self, rhs: CachedFBig<R, B>, ) -> (Self::OutputDiv, Self::OutputRem)

Compute the Euclidean quotient and remainder at the same time.

impl<R: Round, const B: Word> Eq for CachedFBig<R, B>

impl<R: Round, const B: Word> EstimatedLog2 for CachedFBig<R, B>

fn log2_bounds(&self) -> (f32, f32)

Estimate the bounds of the binary logarithm.

fn log2_est(&self) -> f32

Estimate the value of the binary logarithm. It’s calculated as the average of log2_bounds by default.

impl<R: Round, const B: Word> From<CachedFBig<R, B>> for FBig<R, B>

fn from(cached: CachedFBig<R, B>) -> Self

Converts to this type from the input type.

impl<R: Round, const B: Word> From<FBig<R, B>> for CachedFBig<R, B>

fn from(fbig: FBig<R, B>) -> Self

Converts to this type from the input type.

impl<R: Round, const B: Word> From<IBig> for CachedFBig<R, B>

fn from(n: IBig) -> Self

Converts to this type from the input type.

impl<R: Round, const B: Word> From<UBig> for CachedFBig<R, B>

fn from(n: UBig) -> Self

Converts to this type from the input type.

impl<R: Round, const B: Word> From<i8> for CachedFBig<R, B>

fn from(value: i8) -> Self

Converts to this type from the input type.

impl<R: Round, const B: Word> From<i16> for CachedFBig<R, B>

fn from(value: i16) -> Self

Converts to this type from the input type.

impl<R: Round, const B: Word> From<i32> for CachedFBig<R, B>

fn from(value: i32) -> Self

Converts to this type from the input type.

impl<R: Round, const B: Word> From<i64> for CachedFBig<R, B>

fn from(value: i64) -> Self

Converts to this type from the input type.

impl<R: Round, const B: Word> From<i128> for CachedFBig<R, B>

fn from(value: i128) -> Self

Converts to this type from the input type.

impl<R: Round, const B: Word> From<isize> for CachedFBig<R, B>

fn from(value: isize) -> Self

Converts to this type from the input type.

impl<R: Round, const B: Word> From<u8> for CachedFBig<R, B>

fn from(value: u8) -> Self

Converts to this type from the input type.

impl<R: Round, const B: Word> From<u16> for CachedFBig<R, B>

fn from(value: u16) -> Self

Converts to this type from the input type.

impl<R: Round, const B: Word> From<u32> for CachedFBig<R, B>

fn from(value: u32) -> Self

Converts to this type from the input type.

impl<R: Round, const B: Word> From<u64> for CachedFBig<R, B>

fn from(value: u64) -> Self

Converts to this type from the input type.

impl<R: Round, const B: Word> From<u128> for CachedFBig<R, B>

fn from(value: u128) -> Self

Converts to this type from the input type.

impl<R: Round, const B: Word> From<usize> for CachedFBig<R, B>

fn from(value: usize) -> Self

Converts to this type from the input type.

impl<R: Round, const B: Word> FromStr for CachedFBig<R, B>

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, ParseError>

Parses a string s to return a value of this type.

impl<R: Round, const B: Word> Inverse for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The type of the reciprocal.

fn inv(self) -> Self::Output

Compute the multiplicative inverse (reciprocal) of the number.

impl<R: Round, const B: Word> LowerExp for CachedFBig<R, B>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<R: Round> LowerHex for CachedFBig<R, 2>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<R: Round> LowerHex for CachedFBig<R, 16>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<R: Round, const B: Word> Mul for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r CachedFBig<R, B>> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &'r CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r CachedFBig<R, B>> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &'r CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r CachedFBig<R, B>> for FBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r CachedFBig<R, B>> for &'l FBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r CachedFBig<R, B>> for u8

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r CachedFBig<R, B>> for &'l u8

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r CachedFBig<R, B>> for u16

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r CachedFBig<R, B>> for &'l u16

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r CachedFBig<R, B>> for u32

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r CachedFBig<R, B>> for &'l u32

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r CachedFBig<R, B>> for u64

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r CachedFBig<R, B>> for &'l u64

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r CachedFBig<R, B>> for u128

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r CachedFBig<R, B>> for &'l u128

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r CachedFBig<R, B>> for usize

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r CachedFBig<R, B>> for &'l usize

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r CachedFBig<R, B>> for UBig

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r CachedFBig<R, B>> for &'l UBig

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r CachedFBig<R, B>> for i8

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r CachedFBig<R, B>> for &'l i8

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r CachedFBig<R, B>> for i16

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r CachedFBig<R, B>> for &'l i16

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r CachedFBig<R, B>> for i32

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r CachedFBig<R, B>> for &'l i32

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r CachedFBig<R, B>> for i64

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r CachedFBig<R, B>> for &'l i64

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r CachedFBig<R, B>> for i128

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r CachedFBig<R, B>> for &'l i128

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r CachedFBig<R, B>> for isize

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r CachedFBig<R, B>> for &'l isize

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r CachedFBig<R, B>> for IBig

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r CachedFBig<R, B>> for &'l IBig

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r FBig<R, B>> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r FBig<R, B>> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r IBig> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &IBig) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r IBig> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &IBig) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r UBig> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &UBig) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r UBig> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &UBig) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r i8> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &i8) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r i8> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &i8) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r i16> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &i16) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r i16> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &i16) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r i32> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &i32) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r i32> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &i32) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r i64> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &i64) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r i64> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &i64) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r i128> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &i128) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r i128> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &i128) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r isize> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &isize) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r isize> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &isize) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r u8> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &u8) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r u8> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &u8) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r u16> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &u16) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r u16> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &u16) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r u32> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &u32) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r u32> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &u32) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r u64> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &u64) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r u64> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &u64) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r u128> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &u128) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r u128> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &u128) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r usize> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &usize) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r usize> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &usize) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<CachedFBig<R, B>> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<CachedFBig<R, B>> for FBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<CachedFBig<R, B>> for &'l FBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<CachedFBig<R, B>> for u8

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<CachedFBig<R, B>> for &'l u8

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<CachedFBig<R, B>> for u16

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<CachedFBig<R, B>> for &'l u16

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<CachedFBig<R, B>> for u32

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<CachedFBig<R, B>> for &'l u32

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<CachedFBig<R, B>> for u64

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<CachedFBig<R, B>> for &'l u64

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<CachedFBig<R, B>> for u128

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<CachedFBig<R, B>> for &'l u128

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<CachedFBig<R, B>> for usize

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<CachedFBig<R, B>> for &'l usize

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<CachedFBig<R, B>> for UBig

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<CachedFBig<R, B>> for &'l UBig

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<CachedFBig<R, B>> for i8

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<CachedFBig<R, B>> for &'l i8

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<CachedFBig<R, B>> for i16

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<CachedFBig<R, B>> for &'l i16

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<CachedFBig<R, B>> for i32

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<CachedFBig<R, B>> for &'l i32

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<CachedFBig<R, B>> for i64

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<CachedFBig<R, B>> for &'l i64

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<CachedFBig<R, B>> for i128

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<CachedFBig<R, B>> for &'l i128

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<CachedFBig<R, B>> for isize

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<CachedFBig<R, B>> for &'l isize

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<CachedFBig<R, B>> for IBig

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<CachedFBig<R, B>> for &'l IBig

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<CachedFBig<R, B>> for Sign

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<FBig<R, B>> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<FBig<R, B>> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: FBig<R, B>) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<IBig> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: IBig) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<IBig> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: IBig) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<Sign> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: Sign) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<UBig> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: UBig) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<UBig> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: UBig) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<i8> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: i8) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<i8> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: i8) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<i16> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: i16) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<i16> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: i16) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<i32> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<i32> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<i64> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: i64) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<i64> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: i64) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<i128> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: i128) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<i128> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: i128) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<isize> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: isize) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<isize> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: isize) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<u8> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: u8) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<u8> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: u8) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<u16> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: u16) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<u16> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: u16) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<u32> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<u32> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<u64> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: u64) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<u64> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: u64) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<u128> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: u128) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<u128> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: u128) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<usize> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: usize) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<usize> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: usize) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> MulAssign for CachedFBig<R, B>

fn mul_assign(&mut self, rhs: CachedFBig<R, B>)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<&FBig<R, B>> for CachedFBig<R, B>

fn mul_assign(&mut self, rhs: &FBig<R, B>)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<&IBig> for CachedFBig<R, B>

fn mul_assign(&mut self, rhs: &IBig)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<&UBig> for CachedFBig<R, B>

fn mul_assign(&mut self, rhs: &UBig)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<&i8> for CachedFBig<R, B>

fn mul_assign(&mut self, rhs: &i8)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<&i16> for CachedFBig<R, B>

fn mul_assign(&mut self, rhs: &i16)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<&i32> for CachedFBig<R, B>

fn mul_assign(&mut self, rhs: &i32)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<&i64> for CachedFBig<R, B>

fn mul_assign(&mut self, rhs: &i64)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<&i128> for CachedFBig<R, B>

fn mul_assign(&mut self, rhs: &i128)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<&isize> for CachedFBig<R, B>

fn mul_assign(&mut self, rhs: &isize)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<&u8> for CachedFBig<R, B>

fn mul_assign(&mut self, rhs: &u8)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<&u16> for CachedFBig<R, B>

fn mul_assign(&mut self, rhs: &u16)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<&u32> for CachedFBig<R, B>

fn mul_assign(&mut self, rhs: &u32)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<&u64> for CachedFBig<R, B>

fn mul_assign(&mut self, rhs: &u64)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<&u128> for CachedFBig<R, B>

fn mul_assign(&mut self, rhs: &u128)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<&usize> for CachedFBig<R, B>

fn mul_assign(&mut self, rhs: &usize)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<FBig<R, B>> for CachedFBig<R, B>

fn mul_assign(&mut self, rhs: FBig<R, B>)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<IBig> for CachedFBig<R, B>

fn mul_assign(&mut self, rhs: IBig)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<Sign> for CachedFBig<R, B>

fn mul_assign(&mut self, rhs: Sign)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<UBig> for CachedFBig<R, B>

fn mul_assign(&mut self, rhs: UBig)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<i8> for CachedFBig<R, B>

fn mul_assign(&mut self, rhs: i8)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<i16> for CachedFBig<R, B>

fn mul_assign(&mut self, rhs: i16)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<i32> for CachedFBig<R, B>

fn mul_assign(&mut self, rhs: i32)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<i64> for CachedFBig<R, B>

fn mul_assign(&mut self, rhs: i64)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<i128> for CachedFBig<R, B>

fn mul_assign(&mut self, rhs: i128)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<isize> for CachedFBig<R, B>

fn mul_assign(&mut self, rhs: isize)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<u8> for CachedFBig<R, B>

fn mul_assign(&mut self, rhs: u8)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<u16> for CachedFBig<R, B>

fn mul_assign(&mut self, rhs: u16)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<u32> for CachedFBig<R, B>

fn mul_assign(&mut self, rhs: u32)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<u64> for CachedFBig<R, B>

fn mul_assign(&mut self, rhs: u64)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<u128> for CachedFBig<R, B>

fn mul_assign(&mut self, rhs: u128)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<usize> for CachedFBig<R, B>

fn mul_assign(&mut self, rhs: usize)

Performs the *= operation.

impl<R: Round, const B: Word> Neg for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<R: Round, const B: Word> Neg for &CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<R: Round> Octal for CachedFBig<R, 8>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<R: Round, const B: Word> Ord for CachedFBig<R, B>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<R1: Round, R2: Round, const B: Word> PartialEq<CachedFBig<R2, B>> for CachedFBig<R1, B>

fn eq(&self, other: &CachedFBig<R2, B>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<R1: Round, R2: Round, const B: Word> PartialOrd<CachedFBig<R2, B>> for CachedFBig<R1, B>

fn partial_cmp(&self, other: &CachedFBig<R2, B>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<R: Round, const B: Word> Product for CachedFBig<R, B>

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by multiplying the items.

impl<'a, R: Round, const B: Word> Product<&'a CachedFBig<R, B>> for CachedFBig<R, B>

fn product<I: Iterator<Item = &'a CachedFBig<R, B>>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by multiplying the items.

impl<R: Round, const B: Word> Rem for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'r, R: Round, const B: Word> Rem<&'r CachedFBig<R, B>> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &'r CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'l, 'r, R: Round, const B: Word> Rem<&'r CachedFBig<R, B>> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &'r CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'r, R: Round, const B: Word> Rem<&'r CachedFBig<R, B>> for FBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'l, 'r, R: Round, const B: Word> Rem<&'r CachedFBig<R, B>> for &'l FBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'r, R: Round, const B: Word> Rem<&'r CachedFBig<R, B>> for u8

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'l, 'r, R: Round, const B: Word> Rem<&'r CachedFBig<R, B>> for &'l u8

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'r, R: Round, const B: Word> Rem<&'r CachedFBig<R, B>> for u16

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'l, 'r, R: Round, const B: Word> Rem<&'r CachedFBig<R, B>> for &'l u16

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'r, R: Round, const B: Word> Rem<&'r CachedFBig<R, B>> for u32

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'l, 'r, R: Round, const B: Word> Rem<&'r CachedFBig<R, B>> for &'l u32

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'r, R: Round, const B: Word> Rem<&'r CachedFBig<R, B>> for u64

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'l, 'r, R: Round, const B: Word> Rem<&'r CachedFBig<R, B>> for &'l u64

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'r, R: Round, const B: Word> Rem<&'r CachedFBig<R, B>> for u128

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'l, 'r, R: Round, const B: Word> Rem<&'r CachedFBig<R, B>> for &'l u128

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'r, R: Round, const B: Word> Rem<&'r CachedFBig<R, B>> for usize

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'l, 'r, R: Round, const B: Word> Rem<&'r CachedFBig<R, B>> for &'l usize

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'r, R: Round, const B: Word> Rem<&'r CachedFBig<R, B>> for UBig

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'l, 'r, R: Round, const B: Word> Rem<&'r CachedFBig<R, B>> for &'l UBig

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'r, R: Round, const B: Word> Rem<&'r CachedFBig<R, B>> for i8

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'l, 'r, R: Round, const B: Word> Rem<&'r CachedFBig<R, B>> for &'l i8

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'r, R: Round, const B: Word> Rem<&'r CachedFBig<R, B>> for i16

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'l, 'r, R: Round, const B: Word> Rem<&'r CachedFBig<R, B>> for &'l i16

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'r, R: Round, const B: Word> Rem<&'r CachedFBig<R, B>> for i32

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'l, 'r, R: Round, const B: Word> Rem<&'r CachedFBig<R, B>> for &'l i32

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'r, R: Round, const B: Word> Rem<&'r CachedFBig<R, B>> for i64

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'l, 'r, R: Round, const B: Word> Rem<&'r CachedFBig<R, B>> for &'l i64

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'r, R: Round, const B: Word> Rem<&'r CachedFBig<R, B>> for i128

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'l, 'r, R: Round, const B: Word> Rem<&'r CachedFBig<R, B>> for &'l i128

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'r, R: Round, const B: Word> Rem<&'r CachedFBig<R, B>> for isize

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'l, 'r, R: Round, const B: Word> Rem<&'r CachedFBig<R, B>> for &'l isize

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'r, R: Round, const B: Word> Rem<&'r CachedFBig<R, B>> for IBig

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'l, 'r, R: Round, const B: Word> Rem<&'r CachedFBig<R, B>> for &'l IBig

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'r, R: Round, const B: Word> Rem<&'r FBig<R, B>> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &FBig<R, B>) -> Self::Output

Performs the % operation.

impl<'l, 'r, R: Round, const B: Word> Rem<&'r FBig<R, B>> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &FBig<R, B>) -> Self::Output

Performs the % operation.

impl<'r, R: Round, const B: Word> Rem<&'r IBig> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &IBig) -> Self::Output

Performs the % operation.

impl<'l, 'r, R: Round, const B: Word> Rem<&'r IBig> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &IBig) -> Self::Output

Performs the % operation.

impl<'r, R: Round, const B: Word> Rem<&'r UBig> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &UBig) -> Self::Output

Performs the % operation.

impl<'l, 'r, R: Round, const B: Word> Rem<&'r UBig> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &UBig) -> Self::Output

Performs the % operation.

impl<'r, R: Round, const B: Word> Rem<&'r i8> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &i8) -> Self::Output

Performs the % operation.

impl<'l, 'r, R: Round, const B: Word> Rem<&'r i8> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &i8) -> Self::Output

Performs the % operation.

impl<'r, R: Round, const B: Word> Rem<&'r i16> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &i16) -> Self::Output

Performs the % operation.

impl<'l, 'r, R: Round, const B: Word> Rem<&'r i16> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &i16) -> Self::Output

Performs the % operation.

impl<'r, R: Round, const B: Word> Rem<&'r i32> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &i32) -> Self::Output

Performs the % operation.

impl<'l, 'r, R: Round, const B: Word> Rem<&'r i32> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &i32) -> Self::Output

Performs the % operation.

impl<'r, R: Round, const B: Word> Rem<&'r i64> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &i64) -> Self::Output

Performs the % operation.

impl<'l, 'r, R: Round, const B: Word> Rem<&'r i64> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &i64) -> Self::Output

Performs the % operation.

impl<'r, R: Round, const B: Word> Rem<&'r i128> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &i128) -> Self::Output

Performs the % operation.

impl<'l, 'r, R: Round, const B: Word> Rem<&'r i128> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &i128) -> Self::Output

Performs the % operation.

impl<'r, R: Round, const B: Word> Rem<&'r isize> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &isize) -> Self::Output

Performs the % operation.

impl<'l, 'r, R: Round, const B: Word> Rem<&'r isize> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &isize) -> Self::Output

Performs the % operation.

impl<'r, R: Round, const B: Word> Rem<&'r u8> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &u8) -> Self::Output

Performs the % operation.

impl<'l, 'r, R: Round, const B: Word> Rem<&'r u8> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &u8) -> Self::Output

Performs the % operation.

impl<'r, R: Round, const B: Word> Rem<&'r u16> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &u16) -> Self::Output

Performs the % operation.

impl<'l, 'r, R: Round, const B: Word> Rem<&'r u16> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &u16) -> Self::Output

Performs the % operation.

impl<'r, R: Round, const B: Word> Rem<&'r u32> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &u32) -> Self::Output

Performs the % operation.

impl<'l, 'r, R: Round, const B: Word> Rem<&'r u32> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &u32) -> Self::Output

Performs the % operation.

impl<'r, R: Round, const B: Word> Rem<&'r u64> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &u64) -> Self::Output

Performs the % operation.

impl<'l, 'r, R: Round, const B: Word> Rem<&'r u64> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &u64) -> Self::Output

Performs the % operation.

impl<'r, R: Round, const B: Word> Rem<&'r u128> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &u128) -> Self::Output

Performs the % operation.

impl<'l, 'r, R: Round, const B: Word> Rem<&'r u128> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &u128) -> Self::Output

Performs the % operation.

impl<'r, R: Round, const B: Word> Rem<&'r usize> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &usize) -> Self::Output

Performs the % operation.

impl<'l, 'r, R: Round, const B: Word> Rem<&'r usize> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &usize) -> Self::Output

Performs the % operation.

impl<'l, R: Round, const B: Word> Rem<CachedFBig<R, B>> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<R: Round, const B: Word> Rem<CachedFBig<R, B>> for FBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'l, R: Round, const B: Word> Rem<CachedFBig<R, B>> for &'l FBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<R: Round, const B: Word> Rem<CachedFBig<R, B>> for u8

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'l, R: Round, const B: Word> Rem<CachedFBig<R, B>> for &'l u8

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<R: Round, const B: Word> Rem<CachedFBig<R, B>> for u16

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'l, R: Round, const B: Word> Rem<CachedFBig<R, B>> for &'l u16

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<R: Round, const B: Word> Rem<CachedFBig<R, B>> for u32

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'l, R: Round, const B: Word> Rem<CachedFBig<R, B>> for &'l u32

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<R: Round, const B: Word> Rem<CachedFBig<R, B>> for u64

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'l, R: Round, const B: Word> Rem<CachedFBig<R, B>> for &'l u64

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<R: Round, const B: Word> Rem<CachedFBig<R, B>> for u128

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'l, R: Round, const B: Word> Rem<CachedFBig<R, B>> for &'l u128

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<R: Round, const B: Word> Rem<CachedFBig<R, B>> for usize

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'l, R: Round, const B: Word> Rem<CachedFBig<R, B>> for &'l usize

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<R: Round, const B: Word> Rem<CachedFBig<R, B>> for UBig

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'l, R: Round, const B: Word> Rem<CachedFBig<R, B>> for &'l UBig

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<R: Round, const B: Word> Rem<CachedFBig<R, B>> for i8

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'l, R: Round, const B: Word> Rem<CachedFBig<R, B>> for &'l i8

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<R: Round, const B: Word> Rem<CachedFBig<R, B>> for i16

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'l, R: Round, const B: Word> Rem<CachedFBig<R, B>> for &'l i16

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<R: Round, const B: Word> Rem<CachedFBig<R, B>> for i32

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'l, R: Round, const B: Word> Rem<CachedFBig<R, B>> for &'l i32

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<R: Round, const B: Word> Rem<CachedFBig<R, B>> for i64

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'l, R: Round, const B: Word> Rem<CachedFBig<R, B>> for &'l i64

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<R: Round, const B: Word> Rem<CachedFBig<R, B>> for i128

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'l, R: Round, const B: Word> Rem<CachedFBig<R, B>> for &'l i128

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<R: Round, const B: Word> Rem<CachedFBig<R, B>> for isize

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'l, R: Round, const B: Word> Rem<CachedFBig<R, B>> for &'l isize

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<R: Round, const B: Word> Rem<CachedFBig<R, B>> for IBig

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'l, R: Round, const B: Word> Rem<CachedFBig<R, B>> for &'l IBig

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<R: Round, const B: Word> Rem<FBig<R, B>> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: FBig<R, B>) -> Self::Output

Performs the % operation.

impl<'l, R: Round, const B: Word> Rem<FBig<R, B>> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: FBig<R, B>) -> Self::Output

Performs the % operation.

impl<R: Round, const B: Word> Rem<IBig> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: IBig) -> Self::Output

Performs the % operation.

impl<'l, R: Round, const B: Word> Rem<IBig> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: IBig) -> Self::Output

Performs the % operation.

impl<R: Round, const B: Word> Rem<UBig> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: UBig) -> Self::Output

Performs the % operation.

impl<'l, R: Round, const B: Word> Rem<UBig> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: UBig) -> Self::Output

Performs the % operation.

impl<R: Round, const B: Word> Rem<i8> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: i8) -> Self::Output

Performs the % operation.

impl<'l, R: Round, const B: Word> Rem<i8> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: i8) -> Self::Output

Performs the % operation.

impl<R: Round, const B: Word> Rem<i16> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: i16) -> Self::Output

Performs the % operation.

impl<'l, R: Round, const B: Word> Rem<i16> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: i16) -> Self::Output

Performs the % operation.

impl<R: Round, const B: Word> Rem<i32> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: i32) -> Self::Output

Performs the % operation.

impl<'l, R: Round, const B: Word> Rem<i32> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: i32) -> Self::Output

Performs the % operation.

impl<R: Round, const B: Word> Rem<i64> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: i64) -> Self::Output

Performs the % operation.

impl<'l, R: Round, const B: Word> Rem<i64> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: i64) -> Self::Output

Performs the % operation.

impl<R: Round, const B: Word> Rem<i128> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: i128) -> Self::Output

Performs the % operation.

impl<'l, R: Round, const B: Word> Rem<i128> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: i128) -> Self::Output

Performs the % operation.

impl<R: Round, const B: Word> Rem<isize> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: isize) -> Self::Output

Performs the % operation.

impl<'l, R: Round, const B: Word> Rem<isize> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: isize) -> Self::Output

Performs the % operation.

impl<R: Round, const B: Word> Rem<u8> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: u8) -> Self::Output

Performs the % operation.

impl<'l, R: Round, const B: Word> Rem<u8> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: u8) -> Self::Output

Performs the % operation.

impl<R: Round, const B: Word> Rem<u16> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: u16) -> Self::Output

Performs the % operation.

impl<'l, R: Round, const B: Word> Rem<u16> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: u16) -> Self::Output

Performs the % operation.

impl<R: Round, const B: Word> Rem<u32> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: u32) -> Self::Output

Performs the % operation.

impl<'l, R: Round, const B: Word> Rem<u32> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: u32) -> Self::Output

Performs the % operation.

impl<R: Round, const B: Word> Rem<u64> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: u64) -> Self::Output

Performs the % operation.

impl<'l, R: Round, const B: Word> Rem<u64> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: u64) -> Self::Output

Performs the % operation.

impl<R: Round, const B: Word> Rem<u128> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: u128) -> Self::Output

Performs the % operation.

impl<'l, R: Round, const B: Word> Rem<u128> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: u128) -> Self::Output

Performs the % operation.

impl<R: Round, const B: Word> Rem<usize> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: usize) -> Self::Output

Performs the % operation.

impl<'l, R: Round, const B: Word> Rem<usize> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: usize) -> Self::Output

Performs the % operation.

impl<R: Round, const B: Word> RemAssign for CachedFBig<R, B>

fn rem_assign(&mut self, rhs: CachedFBig<R, B>)

Performs the %= operation.

impl<R: Round, const B: Word> RemAssign<&FBig<R, B>> for CachedFBig<R, B>

fn rem_assign(&mut self, rhs: &FBig<R, B>)

Performs the %= operation.

impl<R: Round, const B: Word> RemAssign<&IBig> for CachedFBig<R, B>

fn rem_assign(&mut self, rhs: &IBig)

Performs the %= operation.

impl<R: Round, const B: Word> RemAssign<&UBig> for CachedFBig<R, B>

fn rem_assign(&mut self, rhs: &UBig)

Performs the %= operation.

impl<R: Round, const B: Word> RemAssign<&i8> for CachedFBig<R, B>

fn rem_assign(&mut self, rhs: &i8)

Performs the %= operation.

impl<R: Round, const B: Word> RemAssign<&i16> for CachedFBig<R, B>

fn rem_assign(&mut self, rhs: &i16)

Performs the %= operation.

impl<R: Round, const B: Word> RemAssign<&i32> for CachedFBig<R, B>

fn rem_assign(&mut self, rhs: &i32)

Performs the %= operation.

impl<R: Round, const B: Word> RemAssign<&i64> for CachedFBig<R, B>

fn rem_assign(&mut self, rhs: &i64)

Performs the %= operation.

impl<R: Round, const B: Word> RemAssign<&i128> for CachedFBig<R, B>

fn rem_assign(&mut self, rhs: &i128)

Performs the %= operation.

impl<R: Round, const B: Word> RemAssign<&isize> for CachedFBig<R, B>

fn rem_assign(&mut self, rhs: &isize)

Performs the %= operation.

impl<R: Round, const B: Word> RemAssign<&u8> for CachedFBig<R, B>

fn rem_assign(&mut self, rhs: &u8)

Performs the %= operation.

impl<R: Round, const B: Word> RemAssign<&u16> for CachedFBig<R, B>

fn rem_assign(&mut self, rhs: &u16)

Performs the %= operation.

impl<R: Round, const B: Word> RemAssign<&u32> for CachedFBig<R, B>

fn rem_assign(&mut self, rhs: &u32)

Performs the %= operation.

impl<R: Round, const B: Word> RemAssign<&u64> for CachedFBig<R, B>

fn rem_assign(&mut self, rhs: &u64)

Performs the %= operation.

impl<R: Round, const B: Word> RemAssign<&u128> for CachedFBig<R, B>

fn rem_assign(&mut self, rhs: &u128)

Performs the %= operation.

impl<R: Round, const B: Word> RemAssign<&usize> for CachedFBig<R, B>

fn rem_assign(&mut self, rhs: &usize)

Performs the %= operation.

impl<R: Round, const B: Word> RemAssign<FBig<R, B>> for CachedFBig<R, B>

fn rem_assign(&mut self, rhs: FBig<R, B>)

Performs the %= operation.

impl<R: Round, const B: Word> RemAssign<IBig> for CachedFBig<R, B>

fn rem_assign(&mut self, rhs: IBig)

Performs the %= operation.

impl<R: Round, const B: Word> RemAssign<UBig> for CachedFBig<R, B>

fn rem_assign(&mut self, rhs: UBig)

Performs the %= operation.

impl<R: Round, const B: Word> RemAssign<i8> for CachedFBig<R, B>

fn rem_assign(&mut self, rhs: i8)

Performs the %= operation.

impl<R: Round, const B: Word> RemAssign<i16> for CachedFBig<R, B>

fn rem_assign(&mut self, rhs: i16)

Performs the %= operation.

impl<R: Round, const B: Word> RemAssign<i32> for CachedFBig<R, B>

fn rem_assign(&mut self, rhs: i32)

Performs the %= operation.

impl<R: Round, const B: Word> RemAssign<i64> for CachedFBig<R, B>

fn rem_assign(&mut self, rhs: i64)

Performs the %= operation.

impl<R: Round, const B: Word> RemAssign<i128> for CachedFBig<R, B>

fn rem_assign(&mut self, rhs: i128)

Performs the %= operation.

impl<R: Round, const B: Word> RemAssign<isize> for CachedFBig<R, B>

fn rem_assign(&mut self, rhs: isize)

Performs the %= operation.

impl<R: Round, const B: Word> RemAssign<u8> for CachedFBig<R, B>

fn rem_assign(&mut self, rhs: u8)

Performs the %= operation.

impl<R: Round, const B: Word> RemAssign<u16> for CachedFBig<R, B>

fn rem_assign(&mut self, rhs: u16)

Performs the %= operation.

impl<R: Round, const B: Word> RemAssign<u32> for CachedFBig<R, B>

fn rem_assign(&mut self, rhs: u32)

Performs the %= operation.

impl<R: Round, const B: Word> RemAssign<u64> for CachedFBig<R, B>

fn rem_assign(&mut self, rhs: u64)

Performs the %= operation.

impl<R: Round, const B: Word> RemAssign<u128> for CachedFBig<R, B>

fn rem_assign(&mut self, rhs: u128)

Performs the %= operation.

impl<R: Round, const B: Word> RemAssign<usize> for CachedFBig<R, B>

fn rem_assign(&mut self, rhs: usize)

Performs the %= operation.

impl<R: Round, const B: Word> RemEuclid for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The type of the remainder.

fn rem_euclid(self, rhs: CachedFBig<R, B>) -> Self::Output

Compute the non-negative Euclidean remainder of self % rhs.

impl<'r, R: Round, const B: Word> RemEuclid<&'r CachedFBig<R, B>> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The type of the remainder.

fn rem_euclid(self, rhs: &'r CachedFBig<R, B>) -> Self::Output

Compute the non-negative Euclidean remainder of self % rhs.

impl<'r, R: Round, const B: Word> RemEuclid<&'r CachedFBig<R, B>> for &CachedFBig<R, B>

type Output = CachedFBig<R, B>

The type of the remainder.

fn rem_euclid(self, rhs: &'r CachedFBig<R, B>) -> Self::Output

Compute the non-negative Euclidean remainder of self % rhs.

impl<R: Round, const B: Word> RemEuclid<CachedFBig<R, B>> for &CachedFBig<R, B>

type Output = CachedFBig<R, B>

The type of the remainder.

fn rem_euclid(self, rhs: CachedFBig<R, B>) -> Self::Output

Compute the non-negative Euclidean remainder of self % rhs.

impl<R: Round, const B: Word> Shl<isize> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the << operator.

fn shl(self, rhs: isize) -> Self::Output

Performs the << operation.

impl<R: Round, const B: Word> ShlAssign<isize> for CachedFBig<R, B>

fn shl_assign(&mut self, rhs: isize)

Performs the <<= operation.

impl<R: Round, const B: Word> Shr<isize> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the >> operator.

fn shr(self, rhs: isize) -> Self::Output

Performs the >> operation.

impl<R: Round, const B: Word> ShrAssign<isize> for CachedFBig<R, B>

fn shr_assign(&mut self, rhs: isize)

Performs the >>= operation.

impl<R: Round, const B: Word> Signed for CachedFBig<R, B>

fn sign(&self) -> Sign

Return the sign of the number.

fn is_positive(&self) -> bool

Returns true if the number is positive (including positive zero).

fn is_negative(&self) -> bool

Returns true if the number is negative.

impl<R: Round, const B: Word> SquareRoot for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The type of the square root.

fn sqrt(&self) -> Self::Output

Compute the square root, rounded towards zero by default.

impl<R: Round, const B: Word> Sub for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r CachedFBig<R, B>> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &'r CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r CachedFBig<R, B>> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &'r CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r CachedFBig<R, B>> for FBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r CachedFBig<R, B>> for &'l FBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r CachedFBig<R, B>> for u8

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r CachedFBig<R, B>> for &'l u8

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r CachedFBig<R, B>> for u16

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r CachedFBig<R, B>> for &'l u16

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r CachedFBig<R, B>> for u32

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r CachedFBig<R, B>> for &'l u32

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r CachedFBig<R, B>> for u64

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r CachedFBig<R, B>> for &'l u64

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r CachedFBig<R, B>> for u128

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r CachedFBig<R, B>> for &'l u128

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r CachedFBig<R, B>> for usize

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r CachedFBig<R, B>> for &'l usize

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r CachedFBig<R, B>> for UBig

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r CachedFBig<R, B>> for &'l UBig

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r CachedFBig<R, B>> for i8

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r CachedFBig<R, B>> for &'l i8

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r CachedFBig<R, B>> for i16

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r CachedFBig<R, B>> for &'l i16

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r CachedFBig<R, B>> for i32

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r CachedFBig<R, B>> for &'l i32

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r CachedFBig<R, B>> for i64

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r CachedFBig<R, B>> for &'l i64

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r CachedFBig<R, B>> for i128

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r CachedFBig<R, B>> for &'l i128

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r CachedFBig<R, B>> for isize

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r CachedFBig<R, B>> for &'l isize

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r CachedFBig<R, B>> for IBig

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r CachedFBig<R, B>> for &'l IBig

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r FBig<R, B>> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r FBig<R, B>> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r IBig> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &IBig) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r IBig> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &IBig) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r UBig> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &UBig) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r UBig> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &UBig) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r i8> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &i8) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r i8> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &i8) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r i16> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &i16) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r i16> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &i16) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r i32> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &i32) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r i32> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &i32) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r i64> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &i64) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r i64> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &i64) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r i128> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &i128) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r i128> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &i128) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r isize> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &isize) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r isize> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &isize) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r u8> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &u8) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r u8> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &u8) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r u16> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &u16) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r u16> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &u16) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r u32> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &u32) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r u32> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &u32) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r u64> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &u64) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r u64> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &u64) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r u128> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &u128) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r u128> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &u128) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r usize> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &usize) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r usize> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &usize) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<CachedFBig<R, B>> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<CachedFBig<R, B>> for FBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<CachedFBig<R, B>> for &'l FBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<CachedFBig<R, B>> for u8

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<CachedFBig<R, B>> for &'l u8

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<CachedFBig<R, B>> for u16

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<CachedFBig<R, B>> for &'l u16

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<CachedFBig<R, B>> for u32

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<CachedFBig<R, B>> for &'l u32

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<CachedFBig<R, B>> for u64

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<CachedFBig<R, B>> for &'l u64

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<CachedFBig<R, B>> for u128

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<CachedFBig<R, B>> for &'l u128

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<CachedFBig<R, B>> for usize

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<CachedFBig<R, B>> for &'l usize

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<CachedFBig<R, B>> for UBig

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<CachedFBig<R, B>> for &'l UBig

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<CachedFBig<R, B>> for i8

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<CachedFBig<R, B>> for &'l i8

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<CachedFBig<R, B>> for i16

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<CachedFBig<R, B>> for &'l i16

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<CachedFBig<R, B>> for i32

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<CachedFBig<R, B>> for &'l i32

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<CachedFBig<R, B>> for i64

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<CachedFBig<R, B>> for &'l i64

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<CachedFBig<R, B>> for i128

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<CachedFBig<R, B>> for &'l i128

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<CachedFBig<R, B>> for isize

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<CachedFBig<R, B>> for &'l isize

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<CachedFBig<R, B>> for IBig

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<CachedFBig<R, B>> for &'l IBig

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<FBig<R, B>> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<FBig<R, B>> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: FBig<R, B>) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<IBig> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: IBig) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<IBig> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: IBig) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<UBig> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: UBig) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<UBig> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: UBig) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<i8> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: i8) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<i8> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: i8) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<i16> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: i16) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<i16> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: i16) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<i32> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<i32> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<i64> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: i64) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<i64> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: i64) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<i128> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: i128) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<i128> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: i128) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<isize> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: isize) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<isize> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: isize) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<u8> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: u8) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<u8> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: u8) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<u16> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: u16) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<u16> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: u16) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<u32> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<u32> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<u64> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: u64) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<u64> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: u64) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<u128> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: u128) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<u128> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: u128) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<usize> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: usize) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<usize> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: usize) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> SubAssign for CachedFBig<R, B>

fn sub_assign(&mut self, rhs: CachedFBig<R, B>)

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<&FBig<R, B>> for CachedFBig<R, B>

fn sub_assign(&mut self, rhs: &FBig<R, B>)

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<&IBig> for CachedFBig<R, B>

fn sub_assign(&mut self, rhs: &IBig)

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<&UBig> for CachedFBig<R, B>

fn sub_assign(&mut self, rhs: &UBig)

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<&i8> for CachedFBig<R, B>

fn sub_assign(&mut self, rhs: &i8)

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<&i16> for CachedFBig<R, B>

fn sub_assign(&mut self, rhs: &i16)

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<&i32> for CachedFBig<R, B>

fn sub_assign(&mut self, rhs: &i32)

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<&i64> for CachedFBig<R, B>

fn sub_assign(&mut self, rhs: &i64)

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<&i128> for CachedFBig<R, B>

fn sub_assign(&mut self, rhs: &i128)

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<&isize> for CachedFBig<R, B>

fn sub_assign(&mut self, rhs: &isize)

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<&u8> for CachedFBig<R, B>

fn sub_assign(&mut self, rhs: &u8)

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<&u16> for CachedFBig<R, B>

fn sub_assign(&mut self, rhs: &u16)

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<&u32> for CachedFBig<R, B>

fn sub_assign(&mut self, rhs: &u32)

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<&u64> for CachedFBig<R, B>

fn sub_assign(&mut self, rhs: &u64)

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<&u128> for CachedFBig<R, B>

fn sub_assign(&mut self, rhs: &u128)

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<&usize> for CachedFBig<R, B>

fn sub_assign(&mut self, rhs: &usize)

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<FBig<R, B>> for CachedFBig<R, B>

fn sub_assign(&mut self, rhs: FBig<R, B>)

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<IBig> for CachedFBig<R, B>

fn sub_assign(&mut self, rhs: IBig)

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<UBig> for CachedFBig<R, B>

fn sub_assign(&mut self, rhs: UBig)

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<i8> for CachedFBig<R, B>

fn sub_assign(&mut self, rhs: i8)

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<i16> for CachedFBig<R, B>

fn sub_assign(&mut self, rhs: i16)

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<i32> for CachedFBig<R, B>

fn sub_assign(&mut self, rhs: i32)

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<i64> for CachedFBig<R, B>

fn sub_assign(&mut self, rhs: i64)

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<i128> for CachedFBig<R, B>

fn sub_assign(&mut self, rhs: i128)

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<isize> for CachedFBig<R, B>

fn sub_assign(&mut self, rhs: isize)

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<u8> for CachedFBig<R, B>

fn sub_assign(&mut self, rhs: u8)

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<u16> for CachedFBig<R, B>

fn sub_assign(&mut self, rhs: u16)

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<u32> for CachedFBig<R, B>

fn sub_assign(&mut self, rhs: u32)

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<u64> for CachedFBig<R, B>

fn sub_assign(&mut self, rhs: u64)

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<u128> for CachedFBig<R, B>

fn sub_assign(&mut self, rhs: u128)

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<usize> for CachedFBig<R, B>

fn sub_assign(&mut self, rhs: usize)

Performs the -= operation.

impl<R: Round, const B: Word> Sum for CachedFBig<R, B>

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<'a, R: Round, const B: Word> Sum<&'a CachedFBig<R, B>> for CachedFBig<R, B>

fn sum<I: Iterator<Item = &'a CachedFBig<R, B>>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<R: Round, const B: Word> TryFrom<CachedFBig<R, B>> for u8

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: CachedFBig<R, B>) -> Result<Self, Self::Error>

Performs the conversion.

impl<R: Round, const B: Word> TryFrom<CachedFBig<R, B>> for u16

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: CachedFBig<R, B>) -> Result<Self, Self::Error>

Performs the conversion.

impl<R: Round, const B: Word> TryFrom<CachedFBig<R, B>> for u32

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: CachedFBig<R, B>) -> Result<Self, Self::Error>

Performs the conversion.

impl<R: Round, const B: Word> TryFrom<CachedFBig<R, B>> for u64

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: CachedFBig<R, B>) -> Result<Self, Self::Error>

Performs the conversion.

impl<R: Round, const B: Word> TryFrom<CachedFBig<R, B>> for u128

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: CachedFBig<R, B>) -> Result<Self, Self::Error>

Performs the conversion.

impl<R: Round, const B: Word> TryFrom<CachedFBig<R, B>> for usize

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: CachedFBig<R, B>) -> Result<Self, Self::Error>

Performs the conversion.

impl<R: Round, const B: Word> TryFrom<CachedFBig<R, B>> for i8

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: CachedFBig<R, B>) -> Result<Self, Self::Error>

Performs the conversion.

impl<R: Round, const B: Word> TryFrom<CachedFBig<R, B>> for i16

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: CachedFBig<R, B>) -> Result<Self, Self::Error>

Performs the conversion.

impl<R: Round, const B: Word> TryFrom<CachedFBig<R, B>> for i32

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: CachedFBig<R, B>) -> Result<Self, Self::Error>

Performs the conversion.

impl<R: Round, const B: Word> TryFrom<CachedFBig<R, B>> for i64

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: CachedFBig<R, B>) -> Result<Self, Self::Error>

Performs the conversion.

impl<R: Round, const B: Word> TryFrom<CachedFBig<R, B>> for i128

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: CachedFBig<R, B>) -> Result<Self, Self::Error>

Performs the conversion.

impl<R: Round, const B: Word> TryFrom<CachedFBig<R, B>> for isize

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: CachedFBig<R, B>) -> Result<Self, Self::Error>

Performs the conversion.

impl<R: Round, const B: Word> TryFrom<CachedFBig<R, B>> for UBig

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: CachedFBig<R, B>) -> Result<Self, Self::Error>

Performs the conversion.

impl<R: Round, const B: Word> TryFrom<CachedFBig<R, B>> for IBig

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: CachedFBig<R, B>) -> Result<Self, Self::Error>

Performs the conversion.

impl<R: Round> TryFrom<CachedFBig<R>> for f32

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: CachedFBig<R, 2>) -> Result<Self, Self::Error>

Performs the conversion.

impl<R: Round> TryFrom<CachedFBig<R>> for f64

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: CachedFBig<R, 2>) -> Result<Self, Self::Error>

Performs the conversion.

impl<R: Round> TryFrom<f32> for CachedFBig<R, 2>

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: f32) -> Result<Self, Self::Error>

Performs the conversion.

impl<R: Round> TryFrom<f64> for CachedFBig<R, 2>

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: f64) -> Result<Self, Self::Error>

Performs the conversion.

impl<R: Round, const B: Word> UpperExp for CachedFBig<R, B>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<R: Round> UpperHex for CachedFBig<R, 2>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<R: Round> UpperHex for CachedFBig<R, 16>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.